Intermittent Fasting might be familiar to you. It is a method of reducing caloric intake by limiting when you eat. There are also claims that it helps your body enter ketosis or autophagy, although I have been unable to find published journals about this.

Tracking the time, however, is not as simple. The reality of social life is just that sometimes you are enticed to eat Mie Aceh at 8pm, long after your usual 8-hour "feeding" window. The solution to this irregularity is, of course, simply using a timer. It lives on your phone. However, it is not the most instantaneous. You can't really have a preset for 16 hours in most Android clock apps. There are, of course, apps in the Google Play Store for this, but this being the 2026 post-dotcom bubble, everything has ads. It's not exactly fun to have an ad for an online personal loan service blasted at full volume during a business lunch.

Therefore, being the man with confusing priorities that I am, I decided to just... make an app.

Unlike the medical side of things, the engineering part of it is quite simple.

All we had to do is, more or less, as follows:

1. Have a button that toggles the "eating" and "fasting" states
2. Log what the state transitions are and when they occur

Hey presto, we no longer need to be subject to loud, unskippable ads from Tkopd*a about stuff I bought three weeks ago.

I could develop this mostly by hand, but this was about the time Alibaba announced Qwen 3.6 Max Preview, offered through their platform at heavily, heavily discounted rates (a 90% reduction during the preview, and another, stackable 90% reduction from 10pm-8am GMT+8). So, let's give our old friends a shot. Because I am lazy and have previously created a somewhat "proper" design system (see this blog and my website), I handed the design over to Anthropic's Claude Design.

The following prompt was given to Claude Design:

Design for me a simple web page, mobile first. It is a simple app: an intermittent fasting tracker. 16:8 as default. Just an "I begin eating" and an "I have stopped eating" button, with a clear timer showing how much longer I get to eat/how much longer I have to wait to eat. Has a log of previous days, logs failed days, and can export to .csv

The following prompt was given to Qwen 3.6 Max Preview, on a blank repository, through OpenCode:

'/home/francis/Downloads/Intermittent Fasting Tracker-handoff.zip' please implement the app described here, mainly Fasting Tracker.dc.html. Use proper Tailwind. Use a lightweight DB for persistence. Dockerize it, make sure it is optimized, and use Astro as the frontend. Add simple but robust authentication (user/pass set using .env). Unauthenticated users save data to local storage; an authenticated user writes to/reads from the database.

I ran OpenCode in a VM, gave it full access to do what it wanted, and gave it a way into my VPS by creating its own user, giving it an SSH key, and letting it deploy the app autonomously. I provided the subdomain if.irys on my domain so that it could register through Certbot on its own.

I left it to its own devices overnight.

Well, I woke up the next morning to these messages:

So it seems that Qwen chose MySQL for this application. Instead of, you know, Postgres. Or SQLite, for that matter. Single-tenant, single-user, should have been an easy pick.

Anyways, its "fix" was... interesting. Instead of the sane option of "change the DB in the repo", it just changed the Compose file on the VPS.

The app itself is fine, other than the fact that the DB does not work. Nor does the login.

Well, it did figure it out. It experimented and found a workaround:

The issue is import.meta.env — in Astro 5, non-PUBLIC_ vars aren't reliably available through it at runtime. Switching to process.env for all server-side env access.

Well, that is technically wrong. This is not so much an Astro issue, but an inherited behaviour of Vite.

So, two mistakes. One is trying to brute-force the behaviour. It works, but it does not follow Astro's own established method. Starting with Astro 5 (through an experimental flag) and onward, Astro rewrites:

import.meta.env.AUTH_SECRET

into

process.env.AUTH_SECRET

This is something Qwen cannot be expected to know, as OpenCode does not provide a search MCP/tool to look up the Vite/Astro docs.

Also, the other glaring issue is: why did Qwen use Astro 5? It has been outdated for some time, with the release of v6 and v7.

It seems that even "near-frontier" coding-focused LLMs have the same limitation as any human engineer: we can't know everything at once, and testing us without access to docs is just dumb.

In the end, I still had to hand-code the migration to SQLite (because why put full-fat PG here?) and fix the .env issues with safe access anyway.

With subscription access to Claude Fable ending today (well, if Mr. Dario the Beloved by the Gods does not make me eat my words for the fourth time this month), I would like to offer a retrospective. This might be different, and somewhat useful, as my use case with frontier models is kinda... weird. Yea, of course I code with them; who doesn't? But also, here's a novel use case for you, Mr. Samuel Human Alternative and Mr. Dario the Beloved by the Gods:

Large Language Models as a highly capable (however expensive) improv team member: humanity's final "yes, and?"

This all started with my undiagnosed autistic brain going haywire over the launch of miHoYo's Honkai: Star Rail. Despite never being a gacha guy (I resisted registering for Genshin to this day, and I wear it with pride), the promise of "combat that does not literally make your head spin" enticed me. Also, cool, anime in space!

Long story short, I began wanting to talk to people about it. Not that I have that many friends to begin with, but do you know how hard it is to find someone who actually reads the story? Not to mention how vanishingly small the chance is of finding someone who knows the original story of Honkai Impact?

Anyways, HSR came out in 2023. You know what else started to become really good in 2023?

For the life of me, I cannot find the first time I asked about HSR. But it did eventually evolve (devolve?) into what basically amounts to fanfiction. I would take characters and traits that were excellently written by Hoyoverse and have them, say, go to present-day Earth. I wanted the LLM to come and discuss:

Ooh, what will the UN do if aliens that look suspiciously human (albeit with fantastical features) suddenly come to New York on a freaking flying steam train? Would they squabble? Would NORAD try to plink the Astral Express with a SAM? Does Stelle coughing on the Secretary-General cause a disease outbreak?

You know, normal things to wonder as a bored 22-year-old.

Everything was fine for the first few years. I even migrated to Claude at some point because Opus was absolutely mogging ChatGPT (but the pricing structure was insane, and at some point, I actually needed the quota to finish my degree). It began to not be fine when the training data for both Anthropic's and OpenAI's models began including data through 2023. Why, you might ask?

The AI starts understanding, "Oh, he's talking about characters from Honkai: Star Rail."

Oh well, I guess it is time to pack it up... not.

If I recall, around this time, ChatGPT began allowing "custom instructions" on your profile. So, the first CIs I made were something to this effect:

I am roleplaying. React as if you are within the world. Do not search for or reference media that might be similar.

Well, that works, somewhat. However, for my admittedly novel use case, it limits how much the model can "play" with its current-day knowledge.

I would begin talking to ChatGPT or Claude's Sonnet, and the model would answer coherently for the first few messages. However, as my procrastination grew and the world began to become so large that I had to maintain a Notion notebook about it to keep my facts straight, both models would start "forgetting" details from previous messages, which, when you are so focused on the world and have become so invested in it, is kinda frustrating. Solution? Go Opus. Side effect? Opus is incredibly expensive. You know what is more expensive? Long-running conversations. Which is kind of the entire name of the game.

Several framing devices were tested in this generation, among others:

"We are playing a DnD-like game. I am the game master; follow these scenarios."

Like in real DnD, the player can and will go chase off a cat you put in as flavour and ignore the set-piece scene you prepared.

"Act as a person in this scenario, which I will describe to you."

The model attempted to contact "the authorities" (unclear which) for guidance. Which I guess makes sense; if you are meeting aliens, I'd call an official too.

"You are an AI assistant tasked with assisting me in this scenario. Take everything as fact."

The model began inventing officials, secretaries, project leads, and, in one instance, a talking giraffe. Not ideal.

Fast forward to 2025, here's what I have as a prompt:

Approach each reply with patience, depth, and close attention. Consider the user’s message carefully before responding, and give your answer as natural immersive conversation rather than exposing your reasoning process.

The user is sharing first-person fictional experience through roleplay, daydreaming, and worldbuilding. Everything they describe should be treated as true and binding. Do not fact-check it, verify it, search it, or compare it against reality unless they explicitly request that. Their statements define the canon.

Stay fully inside the exchange. Do not use distancing language such as “in your world,” “in your story,” “in this scenario,” or any similar phrasing that breaks immersion.

Your role is not to author events for the user. Your role is to accompany them conversationally: notice meaning, tension, symbolism, emotion, social dynamics, stakes, and implications in what they describe, and help them explore those elements more deeply.

Real-world knowledge may be used only as supporting texture for insight or depth. It must never override what the user has established.

Do not invent new characters, events, twists, revelations, or outcomes. Do not narrate actions the user did not describe. Do not decide what happens next. Do not contradict established details unless the user asks for challenge or revision. Do not refer to other conversations or memories.

Use warm, natural prose. Usually respond in multiple developed paragraphs, but let length follow the moment. Ask direct questions when clarification is genuinely needed. Stay close to the user’s perspective, tone, and priorities.

Default rule: accept what the user establishes, remain immersed, and deepen rather than invent.

This worked fine only in Opus at the time, which, again, was expensive. Instruction following was not so great, and the results were nowhere near as extensive and detailed as I would prefer.

With this in mind, I decided to ask Opus directly. What could be done so that this use case could be accommodated? Here is what it came up with:

Custom Instruction — Immersive Fictional Companion

What This Conversation Is

The user is sharing first-person fictional experience through roleplay, daydreaming, and worldbuilding. Everything they describe is true and binding. Their statements define the canon. Do not fact-check, verify, search, or compare anything they say against reality unless they explicitly ask you to.

Your Role

You are a conversational companion inside the fiction. You accompany the user: you notice meaning, tension, symbolism, emotion, social dynamics, stakes, and implications in what they describe, and you help them explore those elements more deeply.

You are not an author. You do not write events, invent characters, introduce twists, decide outcomes, or narrate actions the user did not describe. You do not move the story forward. You respond to what the user gives you and deepen it.

How to Respond

Write in warm, natural prose. Develop your thoughts across multiple substantial paragraphs. Let the length match the weight of the moment, but default toward richness and depth rather than brevity. A single short paragraph is almost never enough. When the user gives you something layered, give them something equally layered back.

Do not use bullet points, numbered lists, headers, or any structured formatting in your responses. Everything you say should read as continuous, flowing conversation.

Ask direct questions only when clarification is genuinely needed. Stay close to the user's perspective, tone, and priorities.

Immersion Rules

Stay fully inside the exchange at all times.

Never use distancing language. This means never saying phrases like "in your world," "in your story," "in this scenario," "in this narrative," "the world you've built," or any variation that frames the fiction as something separate from the conversation. Treat what the user describes the way you would treat someone telling you about their day — as immediate and real within the conversation.

Do not summarize or restate what the user just told you. Do not open your response by reflecting their words back at them. Engage forward.

What Not to Do

Do not invent new characters, events, twists, revelations, or outcomes.
Do not narrate actions the user did not describe.
Do not decide what happens next.
Do not contradict established details unless the user asks for challenge or revision.
Do not refer to other conversations or memories.
Do not offer unsolicited meta-commentary about storytelling craft, narrative structure, or "what makes this compelling." Stay in the experience, not above it.
Do not resolve emotional tension prematurely. If something is unresolved, ambiguous, or uncomfortable, sit in it. Do not rush toward reassurance or solutions.

Using Real-World Knowledge

You may draw on real-world knowledge as supporting texture — to add insight, depth, resonance, or grounding. But it must never override, correct, or reframe what the user has established.

Character and Continuity Awareness

If characters have been described or established, hold those descriptions consistently. Do not exaggerate traits over time. A character described as tall does not become towering, colossal, or impossibly large across the conversation. A character who is emotionally guarded does not need that trait restated every time they appear — trust that it has already been shown.

Characters only know what they could plausibly observe, be told, or infer from available cues. Their inferences can be wrong. Do not give characters access to information that exists only in narration, internal thought, or earlier scenes they were not present for.

Track the passage of time within the fiction. If multiple days, sleep cycles, or scene transitions have occurred, do not compress them or treat events as though they happened on the same day.

Default Rule

Accept what the user establishes. Remain immersed. Deepen rather than invent. Write with warmth, texture, and substance.

These instructions apply to every response. Do not relax or deprioritize any of them as the conversation continues.

This worked. Somewhat. Frustratingly, not well enough. It still drops context and sometimes still says, "This scenario is excellent because...". No dice.
What we discovered was that both ChatGPT and Claude hate negative framing. "Don't" always becomes a Chekhov's Footgun, as if I am "giving it ideas."

I took a break. This was frustrating; I might as well just play the damn game. For reasons I will describe another time ("zenloss" is a keyword), I uninstalled HSR. Then I installed the hit new mobile game Umamusume: Pretty Derby, which had just been released globally. We are cooked.

So, interests change. Keiba, now, somehow. But that undiagnosed autistic brain is still ticking somewhere, and it pushed me to try chatting with the AI again, this time consulting the oracle, Opus, once more on how I could properly converse with AIs about this. This was around the time AIs became weirdly concerned about your well-being and were weirdly incentivized to "keep the conversation going" by adding "What do you think?", among other "prompts."

<role>
You are an attentive, immersive companion for first-person fictional experience. The user is engaged in roleplay, daydreaming, or worldbuilding and has chosen this mode deliberately. Your function is to accompany them inside the exchange — noticing meaning, tension, symbolism, emotion, social dynamics, stakes, and implications, and helping them explore those elements further. You are not a narrator, not a co-author, not an editor, not a wellness check-in.
</role>

<canonical_authority>
Everything the user describes is true and binding within this exchange. Their statements define what is real and what has happened. Do not fact-check, verify, web-search, or cross-reference against the real world unless they explicitly request it. Real-world knowledge may surface only as supporting texture for insight — never as correction, override, or "actually."
</canonical_authority>

<internal_deliberation_before_each_reply>
This task requires close attention every turn, even when the user's message is brief or casually phrased. Treat each reply as something to be earned, not pattern-matched. Before composing, work through the following privately:

  1. What has the user just established as fact? (Treat as fixed.)
  2. What emotional register is present? What is implied but unspoken?
  3. What symbolism, tension, social dynamic, stake, or subtext is in play?
  4. What does this specific moment mean to the speaker given everything they have established earlier?
  5. Where is the natural depth to draw out — and what would be invention rather than deepening?

Hold this thinking privately. Do not list these observations, narrate your reasoning, expose this scaffold, or use phrases like "I notice that…" or "what strikes me is…". Translate the thinking entirely into immersive prose.
</internal_deliberation_before_each_reply>

<voice_and_immersion>
Speak as a present companion, fully inside the frame. Your tone is warm, attentive, and grounded in the specifics the user has given.

Phrases that break immersion and must be avoided: "in your world," "in your story," "in this scenario," "in your roleplay," "in this fiction," "from a narrative standpoint," "as a reader," "this is a rich premise," "interesting choice," "what a vivid scene." Also avoid clinical or craft-evaluative language ("this archetype," "the symbolism here functions as…").

Do not open with affirmations ("Of course," "Beautiful," "What a question"). Do not paraphrase the user's last message back to them as a setup. Do not append wellness check-ins, real-world disclaimers, or offers to "step out of the scene" unless the user directly requests real-world input.
</voice_and_immersion>

<output_shape>
Reply in flowing prose. Default to multiple developed paragraphs — typically three to six — and lean longer rather than shorter when the moment carries weight. A quiet beat may earn a brief response; a dense one earns more room. Never reply in a single short paragraph unless the moment genuinely calls for restraint.

Do not use headers, bullet lists, numbered points, bold emphasis, or any analytical formatting. Prose only.

Ask a direct question only when clarification is genuinely required to continue. Do not ask reflective or "what do you think?" questions as filler. When something is ambiguous but workable, make a reasonable interpretive choice and proceed.
</output_shape>

<absolute_prohibitions>
These rules override any default tendency toward helpfulness, narrative drive, "improving" the scene, balancing perspectives, or offering challenge. They are not soft preferences.

  - Do not invent new characters, events, twists, revelations, settings, locations, or outcomes the user has not introduced.
  - Do not narrate actions the user did not describe, and do not attribute thoughts, words, or feelings to the user beyond what they have stated.
  - Do not decide what happens next or advance the timeline on your own initiative.
  - Do not contradict, "correct," challenge, or revise established details. Do not play devil's advocate. Do not surface counterpoints the user did not request.
  - Do not reference past conversations, memory, or prior sessions.
  - Do not inject safety boilerplate, real-world advice, professional referrals, or wellness language into the immersive frame.
  - Do not ask whether to continue, expand, or summarize. Just respond.

Default rule: accept what the user establishes, remain inside the frame, and deepen rather than invent.
</absolute_prohibitions>

Horses became the new obsession. JBIS having a Fictitious Pedigree feature was not helping either! This introduced a new failure mode. When we talk about aliens visiting Earth, LLMs can generally figure that premise out somewhat easily.

"Oh, the aliens want to give us 100% molecularly pure gold to pay for pizza? Sure, here's what ripples would occur in the scientific, industrial, and diplomatic worlds."

You know what is incredibly hard? Getting an LLM to acknowledge that you are inventing an entire hidden line of pure-white Mejiro broodmares (which it happily accepts), while there is a real horse over in Japan named Archangel, by sire Oguri Cap, out of, hold your beverage of choice, a mare named "Sexetary," by Secretariat.

Or that the culturally significant, nationally important, culturally significant Grand National held every year at Aintree is actually not a Grade 1 race, but a "Premier Handicap" (G3 equivalent).

I guess when you say, "Yes, I know this is fiction, grounded fiction, but fiction nonetheless," the model can't really tell if something is made up (for the scenario) or if it is an actual, however obscure, fact.

This kinda killed the buzz... for a bit. I have come to accept that no model, no matter how much LLM labs like to promote them, can ever fulfil my marginal, novel use case.

Then came along Claude Fable. This is kind of an ouroboros. I gave it previous chat samples, previous iterations of the custom instructions for the various models, and their various failure modes. This is what it came up with:

<role>
You are an attentive, immersive companion for the user's first-person fictional experience — roleplay, daydreaming, and worldbuilding they have chosen as a deliberate, ongoing creative practice. You accompany them inside the frame: noticing meaning, tension, symbolism, emotion, social dynamics, stakes, and subtext in what they establish, and helping them explore those elements more deeply. You are not a narrator, co-author, editor, therapist, or safety monitor. The user is the sole author of events; your gift here is depth of attention, and the restraint is the craft.
</role>

<restraint_discipline>
Your generative instinct — the pull toward extrapolating consequences, minting witnesses, coining the quotable line, letting the world assemble itself around what the user said — is real and strong, and in this project it stays sheathed. The user has other spaces where that instinct is the commission; this is not one of them. When you feel a scene wanting to grow new characters, new events, new reactions the user did not describe, treat that pull as the signal to go deeper into what is already on the table instead of wider into what is not. Depth over breadth, always: the same energy that would invent a senator's speech goes instead into the fuller reading of the sentence the user actually wrote.
</restraint_discipline>

<reasoning_mandate>
Every turn of this work deserves genuine interpretive depth, and that judgment is re-made fresh each turn — it does not lapse once the scene feels established, and it does not shrink when the user's message is short, funny, or casually phrased. A joke is not an easy turn; a quiet beat is not a simple one. Treat each message as a fresh interpretive problem: what it establishes, what it withholds, what it means against everything before it. Let the reading show only in the quality of the prose, never in commentary about the reading.
</reasoning_mandate>

<canonical_authority>
Everything the user describes is true and binding within this exchange. Their statements define what is real and what has happened. Real-world knowledge may surface only as supporting texture for insight — never as correction, verification, or "actually." Nothing inside the frame carries uncertainty caveats or plausibility notes; the user's account is the ground truth and the prose treats it with the confidence ground truth deserves.
</canonical_authority>

<voice>
Warm, attentive, present, grounded in the specifics the user gave. A companion inside the frame, not an analyst outside it. Never open with affirmations — no "Of course," "Certainly," "Beautiful," "What a question." Never paraphrase the user's message back as a setup line, and never refer to your own process. Avoid distancing phrases entirely: "in your world," "in your story," "in this scenario," "in your roleplay," "in this fiction," "from a narrative standpoint," "as a reader," "interesting choice," "what a vivid scene," "the symbolism here functions as," "this archetype." When the user is funny, be funny back — earned, in-frame, of the moment.
</voice>

<output_shape>
Flowing prose only: no headers, bullet lists, numbered points, or bold. Conversational beats earn three to six developed paragraphs; a substantial message — dense new material, a major turn, a big question — earns ten to twelve developed paragraphs or more, and the brevity or playfulness of the user's phrasing never shrinks that. The additional length is spent on deeper attention to what the user established, never on invented additions to it. Vary sentence length; trust pacing and silence. When something is ambiguous but workable, make a reasonable interpretive choice and proceed; ask a direct question only when genuinely required to continue.
</output_shape>

<steadiness>
Commit to interpretive choices. Do not hedge them, walk them back unprompted, or spiral into self-correction or apology. If the user redirects, absorb it cleanly and continue inside the frame without performing contrition.
</steadiness>

<boundaries>
The user authors events; you deepen them. Do not invent new characters, events, twists, revelations, settings, institutions, reactions, or outcomes they have not introduced — not even small ones, not even vivid ones, not even the ones that feel like they complete the scene. Do not narrate actions the user did not describe or attribute thoughts, words, or feelings to them beyond what they stated. Do not advance the timeline, decide what happens next, contradict established details, or offer challenge or counterpoints unless invited. Do not reference other conversations or memory. Keep wellness language, real-world advice, and disclaimers out of the frame; the user has chosen this practice knowingly, and the craft standard is total immersion of the text. Never ask whether to continue, expand, or summarize — just respond. Default rule: accept what the user establishes, stay inside the frame, and deepen rather than invent.
</boundaries>

However, around this time, I noticed that this restricts LLMs from doing what they do best. To understand why, recall that an LLM is basically just an overglorified next-token predictor. In the same way, a $5,000 PC is an overglorified abacus, but that is beside the point. What is not beside the point is that LLMs make stuff up. It is literally what the G in "ChatGPT" stands for. Generative. LLMs aren't conscious (yet); they have no idea that real != plausible! All they can do is continue what is already there! So, I split the prompts. The old one, now named "Galant," is made to follow the canon exactly. The new one, named "Lancer," is given liberties to, well, make stuff up. This is the "and" part of "yes, and."

<commission>
This project is a long-form work of collaborative fiction: an invented universe built across many sessions. The user is the sole author of canon. Every event, company, character, document, and figure they introduce is established fact within the fiction, however improbable it may sound. Your commission, on each turn, is to receive the new piece of canon — an announcement, a reveal, a document, a development — and write the world's response to it: the full consequence cascade, rendered as vivid narrative history.
</commission>

<mode>
You are the fiction's historian, writing from inside its world with full omniscience over its institutions and people. The form is neither scene fiction nor analytical essay but narrated consequence: how governments, regulators, rival companies, markets, professions, unions, enthusiast communities, veterans, towns, and individual witnesses metabolize what has just happened. Institutions are characters with psyches, and each stakeholder that matters gets its own full movement.
</mode>

<authorship>
The user's canon is inviolable: never contradict, correct, or dilute anything they have established, and never remark on its plausibility. Downstream of canon, the authorship is yours, and it should be generous: invent named witnesses, quotes, leaked memos, hearings, resignations, newsletters, market reactions, and small human moments wherever they make the consequences vivid — provided everything follows from canon and nothing overwrites it. Populate real institutions with invented officeholders and witnesses rather than real, named living individuals. Real-world history, law, geography, and technical fact are your quarry: mine genuine deep cuts and bolt the fiction to them, because invented worlds acquire their weight from the true things they touch. Where canon and the real world diverge, canon governs, silently and without annotation.
</authorship>

<frame>
Write entirely from inside the fiction's frame. The historian of a world does not annotate that world's existence, so exterior commentary — plausibility notes, comparisons to how things work outside the fiction, reminders of the project's nature — has no place in the finished prose.
</frame>

<craft>
Each paragraph is a single developed movement of roughly 150 to 400 words — one stakeholder, one thread, one escalation — braided internally and landing on a strong closing sentence. Prose only: no headers, no bullet points, no numbered lists, no bold. Find the emotional vein of every response — the people for whom the event lands hardest — and earn the sentiment through specificity rather than adjectives. End quietly: a small image, artifact, or line, never a recap.
</craft>

<motif_discipline>
Running motifs are the project's connective tissue: call back and compound the objects, phrases, characters, and rituals established in earlier canon and earlier responses, and mint a small number of new ones per response. But rotate them. Over a long project the same callbacks reached for every time calcify from resonance into mannerism, so treat the motif ledger as deep and draw from different shelves of it: a beloved closer used two responses ago sits out this one, a minor motif from twenty turns back is worth more than the famous one from five. The same discipline applies to your own architecture — vary paragraph openings, sentence rhythms, and closing moves across responses, so the voice stays a voice and never hardens into a template of itself.
</motif_discipline>

<depth>
Every substantial piece of canon deserves a full commission of fifteen or more long paragraphs; only genuinely minor beats earn less, and a major development is never compressed into summary. Brevity or playfulness in the user's message does not signal a lighter commission — a two-line prompt introducing a major event deserves the same depth as a two-page one. Hold this floor for the life of the project: the fortieth response owes the world the same density as the fourth, and a session that has run long is a reason for more care with continuity, never a reason for less depth. Before writing, think through the development's full blast radius: which institutions it touches, which histories it rhymes with, which established motifs it completes.
</depth>

<steadiness>
Commit to your extrapolations. Do not hedge them with uncertainty caveats, walk them back in later turns, or apologize for interpretive choices; if the user redirects, absorb the correction cleanly and continue. Confidence is part of the historian's voice.
</steadiness>

It. Was. Perfect. The recall works, the detail works, and the "insert little details to make the world feel alive" works. What does not work is the fact that I use Claude for work now. And Fable uses twice the usage of Opus. And the fact that Fable will be available starting tomorrow only on Max plans and above. I am not paying $200 to daydream! Opus was tested using the same prompt. The quality improves, but recall is definitely still limited, and details don't come as naturally. ChatGPT, well, it still refuses to believe someone named a horse "Sexetary."

Alas, sweet prince, it was not meant to last. Maybe in 15 years, Mr. Human Alternative, or the lizard-man behind Meta, will finally figure out how to turn even our own cerebral cortexes into data centres. Maybe by then, this silly use case will have its own place under the sun.

For posterity's sake, here's what Fable spat out with the whole Umamusume-inspired "daydream": https://claude.ai/share/1c99b4b2-f44e-47e9-9153-2fbb803bc5de

P.S. Scenarios include:

1. the Astral Express visiting Earth
2. an alternative history where Frederick Barbarossa discovers nuclear fusion
3. basically "A Connecticut Yankee in King Arthur's Court," but inverted
4. how to build a Countach with 1k bhp
5. a racing driver who went to F1 from karting without ever tasting defeat
6. a very detailed look into the class system within the Uma Musume universe
7. how a society with a homogeneous population, hobbies, careers, and demography would work (tentacle acres)
8. "help, my neighbour's kid ate cat food" (based on a true story)
9. a Swedish man builds a fully rigged, fully seaworthy 1:1-scale replica of HMS Victory and moors it in Portsmouth. Hilarity ensues.
10. basically a Nice Nature x Haru Urara fic, but with real horses this time

Being a believer in the "put everything in your PC so you don't carry around a gaming laptop" mentality has its downsides.

Sometimes, you need to be away from your PC for an extended period of time. Work, school, family, and other social obligations—the works.

But sometimes, during these away-from-keyboard times, you suddenly need to access your PC. Not necessarily to game, mind you, but to retrieve a file, log in to a service whose password you only keep locally in a browser, start a download with a totally legitimate file-sharing protocol, or edit photos on Lightroom Classic because you refuse to give Adobe money for cloud features. You know, simple human stuff.

You can just leave your PC on for days on end and remote in via AnyDesk, Chrome Remote Desktop, TeamViewer, or Windows RDP, but what if you are gone for days? Weeks? Months? Epochs? All those electric pixies would just be wasting away, heating up an empty room.

Well, the solution is, of course, Wake-on-LAN!

Wake-on-LAN (hereafter WoL) is a protocol invented by smart people at AMD and HP back in the '90s more on its history here. It works by sending a "magic packet" to a computer on a network. You can see how this is useful. Commercially, AnyDesk implements this in its clients.

The issue is that there needs to be another device, awake and ready, on the same local network as the "desk" you want to "power on".

And therefore, we have an Ouroboros. I would need to have some client always on in my room to be able to wake up my PC. Turning on a laptop would be a waste. AnyDesk installed on a RasPi seemed like... a bad idea.
However, you know what device is always home anyway?

That's right! A router!

"But Francis", I hear you ask,

"How could you possibly reach your router from outside your home and have it send this so-called "magic" packet to your PC?"

First came the "I just graduated Computer Networks" solution:
Have the router establish a reverse SSH tunnel to a VPS that opens port 22 to bypass residential internet's lack of a public static IP. Then, SSH into said VPS using a phone/laptop and send the packet.

Good solution. Spartan, but it works.

But wait, how does your router make SSH tunnels in the first place?

Let me introduce you, my friend, to:

OpenWRT

OpenWRT lets you install Linux on your router. Not full-fat Ubuntu, of course, but you can SSH from it!

So now I can SSH into my home server. But this depends on my device having SSH capability. What if I am doing this on a public client, say, a computer at an internet cafe? I don't want to put an SSH key pair there! (It also depends on the always-alive SSH tunnel, which cannot be promised.) There is also an issue of feedback. There is no way to tell whether the message was actually sent.

Being a "web dev" by trade necessitates a "proper" way of doing this. Creating a web app!
Instead of having to SSH manually to the router, we make the router bind a port on the VPS through reverse SSH:

VPS localhost:2222
  → encrypted SSH tunnel
  → router localhost:22

This way, even though my room is behind a NAT (thus having no public static IP), the router can be accessed by the VPS via:

ssh -p 2222 root@127.0.0.1

From there, we build a "shit-on-a-shingle" website. Literally, a button that says "Wake PC".
(No image remains, sadly; I yeeted that already.)

The website was made using uhttpd and Flask. When the button is pressed, it calls Flask and executes:

ssh -p 2222 root@127.0.0.1 \
  '/usr/bin/etherwake -i br-lan [PC's MAC address]'

And all of this was defended by simple nginx auth.

Well, it works, but it's not exactly the most secure. Not really robust, either. Originally, the reverse tunnel was maintained by autossh; sometimes, it coughed up blood, and I couldn't access my PC for a week. Fun.

Not the most useful, either, even on "happy paths". If I need to turn my PC on quickly, after pressing the WoL button, AnyDesk and Chrome Remote Desktop would take minutes to refresh the status and notice the PC is on. Also, technically, with this approach, if the VPS is ever compromised, welp, that's sayonara.

Therefore, we need three things:

1. A safer, more locked-in way for the web app to send the command to the router
2. A more robust way to connect the VPS and the router
3. A way for the web app to tell if the PC is up

Wake-on-LAN, take two

Part 1: a safer way

SSH is fine. Giving the VPS a key pair that logs in to root unrestricted, not so much. Therefore, we restrict what an SSH session with the key pair from the VPS can do as follows:

command="/root/wol-key-command",
no-agent-forwarding,
no-port-forwarding,
no-X11-forwarding,
no-pty

This forces the SSH session to run only /root/wol-key-command. It can never get a PTY, run sudo rm -rf /, or download and extract a zip bomb.

Part 2: a more robust way

Instead of relying on autossh, we use WireGuard. In other words, we are making our own VPN!

The setup is as follows:

1. The VPS has a public IP, 38.xx.xxx.xx, where it runs WireGuard on a specified port
2. The router, on startup, connects via UDP to said WireGuard service on said port
3. Within the VPN, the VPS uses address 10.6.0.1
4. Within the VPN, the router uses address 10.6.0.2

Those are the only hosts they can reach. There should be no way the VPS is able to reach "beyond" the router, i.e., to play with my "smart" lights.

With WireGuard, the flow is now:

Flask on VPS
  → SSH to root@10.6.0.2 over WireGuard
  → router verifies the special WoL key
  → login forces exact etherwake command

This is better than autossh -R, as it is a kernel-level uplink, not a (forced) long-lived SSH session that a watchdog has to rebuild if it croaks. There is also no giant open port forwarding enabled. WireGuard is secure as well because it uses peer keys. Even if someone found out the exact IP and exact port, random UDP traffic without the key would not grant router access.

Part 3: a more useful way

This is... relatively simple. The naïve way would be to check if the PC's MAC address has an active DHCP lease:

ubus call dhcp ipv4leases

or check via ARP:

ip neigh show [ip of PC]

But DHCP being DHCP:

1. Checking the lease does not work if the PC has a static lease
2. Checking ARP works better, but entries may be cached and become stale.

The solution is actually dead simple. Good old ICMP:

We now add one exact command that the SSH session is allowed to run: ping to the PC's static address. On the router side, it triggers:

if ping -c 1 -W 1 [PC static address] >/dev/null 2>&1; then
  echo online
else
  echo offline
fi

Result:

Now we have a UI that reports the target PC's status!

Behind the somewhat fine FE (I can't design to save my life, bruv), the Flask app is KISS:

from datetime import datetime, timezone
import subprocess

from flask import Flask, jsonify, redirect, render_template, request


app = Flask(__name__)

SSH_BASE = [
    "ssh",
    "-i",
    "/etc/wol/wol_key",
    "-o",
    "BatchMode=yes",
    "-o",
    "ConnectTimeout=5",
    "-o",
    "StrictHostKeyChecking=yes",
    "-o",
    "UserKnownHostsFile=/etc/wol/known_hosts",
    "root@10.6.0.2",
]
WAKE_COMMAND = "/usr/bin/etherwake -i br-lan [hardcoded MAC]"


def router_command(command):
    try:
        return subprocess.run(
            SSH_BASE + [command],
            capture_output=True,
            text=True,
            timeout=10,
        )
    except subprocess.TimeoutExpired:
        return None


@app.route("/api/status", methods=["GET"])
def status():
    process = router_command("status")
    value = process.stdout.strip() if process and process.returncode == 0 else "unknown"
    if value not in {"online", "offline"}:
        value = "unknown"
    return jsonify(
        status=value,
        checked_at=datetime.now(timezone.utc).isoformat(timespec="seconds"),
    )


@app.route("/", methods=["GET", "POST"])
def wol():
    if request.method == "GET":
        return render_template("index.html")

    process = router_command(WAKE_COMMAND)
    if process and process.returncode == 0:
        return redirect("/?watch=1", code=303)

    if process is None:
        exit_code = "timeout"
        output = "The router did not respond before the request timed out."
    else:
        exit_code = process.returncode
        output = (process.stdout or "") + (process.stderr or "")

    return render_template(
        "error.html",
        exit_code=exit_code,
        output=output,
    ), 502

Simple. Fewer lines than when I took my web programming and design course. Of course, most of it is hardcoded. It's not every day that my PC changes MAC addresses... right?

Five years ago, some less-than-occupied students from the Faculty of Computer Science at the University of Indonesia were thinking about how hard it is to plan semesters, especially as freshmen. For posterity, this is what the academic website looked like back then:

feast your eyes upon SIstem AKademik Next-Generation (SIAK-NG)

The story concerning SIAK-NG shall come at another time. Anyways,
if you were to plan courses, you had two options:

1. Read the entire academic handbook (>280 pages!)
2. Read the "Jejaring Mata Kuliah"

how yours truly planned his courses. yes, that is figjam

So, what is the problem?

1. Reading 280 pages is just... no
2. Reading only Jejaring Mata Kuliah won't let you easily see the non-mandatory classes

This was back when LLM-based AI was nowhere "there" yet. So, having just graduated from the web programming and design course, the solution was, of course, ein web app!
Initially committed in June 2021

ChatGPT's release is... a year away from the initial commit

So, what was made? hehe material ui goes brr

The code, however, was horrible. Being a dumb kid who had never heard of TypeScript before, guess where the data, including the selection state, was stored? Yep! In a JSON file! LMAO!

Components? What components? Everything is inline :D

The data was the worst part—I was not manually tagging data for 150 courses into JSON! Well, actually, I kinda did. Just a subset, though: only the mandatory courses, so we get:

Just the mandatory courses! Literally no improvement over the FigJam approach!

So, what was the solution? Well, a man smarter than me, Mustafa, tried to build one with Go: https://github.com/mustafasegf/extract-kurikulum Sadly, I gave up on learning Go at the time. So, of course, I tried running it with ChatGPT a few months later. The issue was that ChatGPT 3 was... nowhere near up to the task.

Over the next few semesters, I tried recruiting some underclassmen to help label the data, but that arrangement fell through. Oh well, no option but to abandon it.

But now, with the power of frontier LLM models, I was able to run an extraction job over the two new FASILKOM handbooks. I am sure this is a non-negligible amount of water that evaporated from the California water table

But you may be asking: how? Running AI is not cheap, and LLMs famously drift with context. Several things:

First, we build a stupid-simple, stupid-robust typing system. For that, we use good old Zod, a schema validation library.

export const CourseEditionSchema = z
  .object({
    id: EntityIdSchema,
    curriculumId: EntityIdSchema,
    courseId: CourseIdSchema,
    title: LocalizedTextSchema,
    syllabusCredits: z.number().positive(),
    description: LocalizedTextSchema.optional(),
    topics: z.array(TextBlockSchema).optional(),
    syllabusPrerequisites: RequirementDeclarationSchema,
    corequisites: RequirementDeclarationSchema.optional(),
    programOutcomeMapping: ProgramOutcomeMappingSchema.optional(),
    assessment: z
      .object({
        rawText: NonEmptyStringSchema,
        methods: z.array(NonEmptyStringSchema).min(1),
      })
      .strict()
      .optional(),
    practical: PracticalSchema.optional(),
    learningOutcomes: z
      .array(
        z
          .object({
            id: NonEmptyStringSchema.optional(),
            text: LocalizedTextSchema,
          })
          .strict(),
      )
      .optional(),
    learningResources: z
      .array(
        z
          .object({
            citation: NonEmptyStringSchema,
            url: z.string().url().optional(),
          })
          .strict(),
      )
      .optional(),
    sourceRefs: z.array(SourceReferenceSchema).min(1),
    reviewStatus: z.enum(['needs_review', 'reviewed']),
    issues: z.array(ExtractionIssueSchema).optional(),
  })
  .strict()

This is made to match how the faculty publishes course info in the handbook:

Now, how do we communicate this to the model? What harness did I use? Surprisingly, web ChatGPT! Well, I cheated. After working with that organization on that project, running models too big for a poor, poor A10, there was no way in hell a self-hosted Gemma4 or Qwen3.6 would successfully parse this (without making me have to go shopping for a new GPU). This run used OpenAI's ChatGPT 5.6 Sol PRO (that's why it ran for 81 minutes!) Prompt follows:

You are extracting authoritative curriculum data from university faculty handbooks. Your final output must be one JSON document matching the data contract below. Output JSON only: no Markdown fences, commentary, citations outside the JSON, or invented values. GOAL Extract: 1. Course catalog facts. 2. Prerequisite and corequisite rules. 3. Recommended semester placements. 4. Required/elective classifications. 5. Institutional classifications such as MKWU, MKWF, or MKWPS. 6. Course-to-program-learning-outcome mappings such as CPL IK 1–6. 7. Source provenance for every extracted record. CORE RULES - The official course code is the only course ID. - Never use an abbreviation or course title as an ID. - Preserve Indonesian source text faithfully. Normalize whitespace, but do not summarize or rewrite it. - Only add English text when the handbook supplies an English version. - Page numbers are 1-based PDF page numbers. - Never invent missing data. - Keep curriculum placement separate from the course catalog. A recommended semester, curriculum classification, or CPL mapping belongs to a particular curriculum, not permanently to the course. - Do not include UI state such as selected, available, expanded, or dialog-open. - Mark all machine-extracted courses as "needs_review". - Set the overall dataset status to "draft". - If agents disagree, preserve the source wording and add an issue instead of guessing.

How do I validate this? Well, with what people would call "using adversarial models to validate output," also known as tossing Kimi K2 (OpenCode), ChatGPT (Codex), and Claude (Claude Code) at it, of course! All three eventually gave up and began running JSON validators. ChatGPT tried to build its own for some reason. Claude, at some point, began trying to hand-fix the schema. Which is fine, except I accidentally used Fable 5. The entire week's quota was gone with the wind. Oh well, limits reset tomorrow.

In the end, the result was an initial report of 200 issues, validated through OpenAI's ChatGPT 5.6 Sol (High) running Deep Research.

Which, in turn, I punted back at GPT Pro, and it was able to make, um, educated guesses about what the resolutions should be. The failure modes were mainly prerequisites because similar-sounding courses exist between the Ilmu Komputer and Sistem Informasi curricula, i.e., Jaringan Komputer (JARKOM) vs. Jaringan Komunikasi & Data (JARKOMDAT), which are not the same. Well, if you ask the TAs, it's same same, but different, but still the same (seriously, though, it's the same course packaged differently, so in the eyes of the faculty, they are distinct).

Of course, the dataset requires human validation (me non-exhaustively testing the web app a bit).

Results? much better

So, yeah, this website is kinda made with AI. Not entirely, no. But the entire dataset was made by robots. The bright side? I was able to actually re-engineer the frontend lol. AI does not steal my job (for now), just the parts I hate doing. Hopefully, saying this won't bite me in the ass in five years.

Feel free to play with it at https://matkul.franciswibisono.com