Fanfiction is the best exercise in system design

Beautiful, beautiful fanfiction. Where you inherit the structure, characters, rules, magic system, and tone from the people who came before you — and then you proceed to ignore all of it and write a sixty-page novella that shares nothing with the source material except that one of the characters has the same name.¹

Either that, or you decide to be a bit more faithful. You actually sit with the systems, characters, history, and tone the author built, and you try to add something that fits. That second mode — the faithful one — is what I want to talk about, because I think it's one of the cleanest exercises in system design I've ever encountered, and I think nobody talks about it that way because the word "fanfiction" sounds unserious.

It is not unserious. It is a Sudoku grid that someone else has partially filled in, and your job is to fill in the rest without breaking the puzzle.²

Two halves of the same skill

The argument is in two halves and I'll signpost them upfront so it's clear where we're going:

1. Worldbuilding develops systems intuition. Original worldbuilding teaches you to see relationships, constraints, and consequences — the same instincts you need to design any non-trivial system.
2. Fanfiction develops inherited-system intuition. It adds the constraint that the system already exists, has rules you didn't write, and has users (readers) who already know it. That's the constraint almost all real engineering happens under.

The first part is the warmup. The second part is where it gets interesting.

Part I: worldbuilding develops systems intuition

A good fictional world feels alive because it exceeds the plot. You get the sense that if the protagonist left the room, the room would keep existing. That effect doesn't come from one big thing. It comes from a lot of quiet machinery running underneath: geography, weather, food, trade, government, religion, technology, language, class, family structures, institutions, factional incentives.

The beauty of worldbuilding is that none of these are decorative. They depend on each other.

Pick any one of them and pull on the thread. A mountain range is not a pretty line on a map. It changes weather (rain shadows on one side, lush valleys on the other), which changes what grows there, which changes diet, which changes trade routes, which changes which cities get rich, which changes where armies march, which changes which language ends up dominant on which side of the ridge, which changes which gods get worshipped, which changes what counts as a sin, which changes who gets to marry whom. A single mountain range is a tech tree that expands about as fast as TREE ↗ or SSCG ↗.³

That instinct — "what else does this change?" — is identical to the instinct you need when picking a database, an API boundary, a framework, a deployment model. None of those are isolated either. A choice of database ripples into latency, cost, observability, what kinds of queries are easy, what kinds of migrations you can do later, what your hiring pool looks like, and how nervous your on-call rotation feels at 3am. The transferable skill isn't memorizing domains. The transferable skill is the reflex to look at any single decision and ask what its second-order effects are.

The other thing worldbuilding teaches is how to hold complexity without flattening it. Big fictional worlds get too large to keep in your head all at once. You have timelines, maps, customs, family histories, power systems, exceptions, things you've contradicted and need to retcon. Good writers learn to ask:

• What matters for this scene?
• What can stay implied?
• What is emotionally load-bearing?
• What is structurally load-bearing?
• What can I simplify without making it false?

This is decomposition. This is what you do when you're staring at a million-line codebase and you need to make one change without reading all of it. You build a working model in your head, you decide what details to fade out, and you commit to a level of abstraction that's right for the task in front of you. Worldbuilding is just decomposition with vibes.

Part II: fanfiction is where it gets hard

Original worldbuilding starts with a blank page. Fanfiction starts with attachment.

When you sit down to write fanfic, you don't get to choose anything from scratch. You inherit:

• Characters people already recognize and have opinions about
• Rules people remember (and will email you about if you break them)
• Places with emotional weight
• Relationships with history
• Events that happened on-page and cannot be casually undone
• A tone that defines what the work "feels like"

You are not asking what could happen in a story. You are asking what could happen here, to these specific people, in this specific world, without the world ceasing to feel like itself.

An empty Sudoku grid gives you freedom. A partially filled grid gives you meaning through constraint. Every new move has to fit the pattern already emerging.

The empty grid is harder in one sense (you have nothing to push against) and easier in another (anything you put down is allowed). The partially filled grid flips that. You can't put anything you want in any cell, but the cells that do fit feel earned in a way an empty grid can never give you.

This is exactly the difference between greenfield engineering and working in a mature codebase.

Canon is an inherited structure, not a list of facts

The thing fanfic writers learn — usually by getting yelled at on the internet — is that canon is not just a database of who said what on which page. Canon is a body of assumptions, patterns, tensions, and expectations, some of which the original author put there on purpose, some of which they put there by accident, and some of which the readership built up around the work without anyone noticing.

To write good fanfiction, you have to read canon almost architecturally. You're asking the same questions you'd ask walking into a mature codebase: what are the deep rules of this world versus what's incidental detail, what can you bend versus what will get you flamed, which contradictions are interesting versus which are load-bearing, where are the natural extension points.

The dangerous failure mode is the same in both domains too. It's assuming that because nobody wrote a rule down explicitly, the rule isn't there. A character "wouldn't say that" is the literary version of an undocumented behavior half the system has come to depend on. The original author may not have realized they were establishing it. The readers definitely did.

The best fanfic extends without flattening

Good fanfic doesn't just obey canon. It interprets it.

It might fill a gap (what was that minor character doing during the timeskip?). It might follow a side character into their own arc. It might change one premise and trace the consequences. It might repair a contradiction the author left behind. It might move the story into a new setting entirely (the "AU"). What the best versions of these have in common is that they preserve something essential — usually the emotional logic, sometimes the thematic core — while letting something new exist.

This is the same judgment call as the mature engineering ones: when to preserve compatibility and when to break it, when to refactor and when to leave it alone, when to fork and when to extend, when an edge case is worth handling and when it's worth ignoring. The art isn't obedience. The art is knowing what kind of change the system can survive.

Baoshu's The Redemption of Time ↗ is the cleanest worked example I have.⁴ It's a fanfic continuation of Liu Cixin's Remembrance of Earth's Past trilogy that got popular enough on the Chinese internet that the publisher reached out and made it canon. On paper it follows every rule — characters preserved, setting preserved, broad plot vectors preserved — but the thing that actually made the original work feel alive (the scientific seriousness, the philosophical weight, the cosmic-horror gravity of every set piece) gets replaced with wish fulfillment. Yun Tianming ends the book with Sophon as a "gorgeous and flirtatious" servant, which is an actual sentence in an actual published continuation of one of the most respected science fiction trilogies of the century. Baoshu didn't break a single rule. He kept all of them and lost the system anyway.

That is the most useful thing fanfiction can teach you about engineering, and I mean it: a system's invariants are not always the things it has written down. Sometimes they're the texture, the tone, the way of doing things that everyone has absorbed without articulating. You can technically comply with every rule, ship the change, watch all the tests pass, and still ruin the system. Fanfic writers learn to feel this. Engineers usually learn it the hard way.⁵

Readers are not obstacles, they are evidence the system is alive

Fanfic has an unusually scary audience. Readers will notice when a character feels wrong, when a rule got used too conveniently, when a timeline doesn't add up, when the tone is off by a degree. The Jujutsu Kaisen fandom watched Gege Akutami offscreen Gojo Satoru in chapter 236 and responded by generating, in roughly a week, a sub-genre called Lobotomy Kaisen — thousands of memes, pseudo-theories, and denial-driven absurdisms trying to retcon a fix, including but not limited to personified speech bubbles fighting each other in mock duels. Half of it was joking. The other half was deadly serious continuity work, performed at volume, by an audience that knew the system better than any individual reader could.

This is sometimes annoying when you're the writer being yelled at. It is also exactly what tells you the world is real to them.

The parallel with mature software is so clean it's almost cheating. Hyrum's Law ↗ — "with a sufficient number of users of an API, all observable behaviors of your system will be depended on by somebody" — is just the engineering restatement of "you cannot quietly change how this character talks, because half the fandom has built an entire reading on that one mannerism." Users (readers) rely not only on the documented contract but on the workflows and conventions and quirks that grew up around it. A living system is partly made of the expectations people have built around it, and you don't get to choose which expectations count.

The mature response, in both domains, is not to resent this. It's to take it as confirmation that the thing you're working on actually matters to someone, and then to make your changes with that audience in mind.

One more, because the example is too good

Sometimes the inheritance is the whole point. Jean Rhys's Wide Sargasso Sea is a prequel to Jane Eyre written from the perspective of Rochester's first wife — the woman locked in the attic in Brontë's original, who barely speaks and exists mostly as a plot device. Rhys takes that one inherited fact and uses it as a load-bearing beam for an entirely new structure: a postcolonial, proto-feminist novel about how a Creole woman in 1830s Jamaica ends up as the madwoman in the attic.

The interesting thing is that the book only works because it's a fanfic. As a standalone novel about a woman's life in colonial Jamaica it would be good and largely ignored. The reason it lands is that every reader is silently doing the diff against Jane Eyre in their head, and every gap between Rhys's version and Brontë's version becomes an argument. The original system is the thing being argued with, and that's only possible because the original system already exists.

This is the most extreme version of inheriting a system to do something the original author would have hated. Brontë would not have signed off on it. Rhys did it anyway, and it is now generally agreed to be one of the great novels of the 20th century. Sometimes the right move in an inherited system isn't to preserve the original author's intent. Sometimes it's to use their structure as the platform for an argument they would have lost.

(I'm not endorsing this as a general engineering strategy. Forking the load-bearing legacy system to make a political point about your manager is a career-limiting move.)

So why does this transfer

The standard pitch for "creative writing makes you a better engineer" usually stops at it teaches you to communicate. That's true and boring. The more interesting transfer is the one I've been describing this whole post: worldbuilding teaches you to think in relationships, and fanfiction teaches you to do that thinking inside a system you didn't design, for people who already love it.

Almost no engineer ever gets to do greenfield work. Even the rare ones who do are usually building on top of a stack — a language, a framework, an operating system, a set of conventions — that they inherited from someone else. The default condition of engineering is: a system already exists, it has rules you didn't write, it has users with opinions, and your job is to add something that fits.

That's just fanfic with worse prose.⁶

The instinct to ask what else does this change, what's load-bearing, what can I touch without breaking the feel of the thing, what do the users already silently depend on — those aren't engineering instincts that happen to also apply to fiction. They're systems-thinking instincts, full stop, and fiction is a remarkably honest place to practice them because the feedback loop is fast and the cost of breaking something is just a bad chapter instead of a Sev-1.

So no, every character is not secretly a microservice and every plot is not secretly an API call. The point is that both practices reward the same deeper skill — understanding a complex living structure well enough to change it responsibly.

Worldbuilding teaches you to build worlds.

Fanfiction teaches you to enter one, listen to it, and add something that belongs.

I think the second one is the harder skill, and I think it's the one that actually shows up at work.⁷

That is to say, go and write some fanfiction already.

Receipts

In the interest of not just claiming credentials, here are mine. I am not claiming any of these are good. I am claiming they happened.

1. LFS (~17,500 words, 22 chapters, unfinished) — A dumb protagonist named Bob stumbles through a nonsense quest involving sentient potatoes, math teachers, banana-peel slapstick, and an evil tomato-father reveal. Co-written with chapters handed off between authors. The system being inherited was, mostly, the previous chapter. Sometimes successfully.

2. LFS V2 (~25,000 words, 37 chapters, complete) — A reboot in which Bob is narrated by his own sentient earwax and accidentally starts a war against an aspiring overlord named Alice after blaming her for stealing his pet potato. Contains multiple Shakespearean and Italian sonnets (because of Wordmasters).

3. Elari Celestium (~10,500 words, solo, complete) — Genshin Impact contest entry. Sangonomiya Kokomi gets isekai'd to a world governed by celestial sky-threads, befriends a local girl named Yienne, and has to find a confluence resonant with her identity to get home.

4. Ingram (~750 words plus a ~350-word author's note, solo, complete) — A rewrite of a scene from Jane Eyre from Blanche Ingram's perspective, reframing her as a proto-feminist navigating Victorian marriage politics. School assignment. Easily the most polished thing on this list, mostly because it was an assignment.

5. Improvised Shakespeare (~5,900 words, 5 acts, unfinished) — A blank-verse sequel to Romeo and Juliet in which a banished Romeo and a possessive, shotgun-summoning Juliet (inspired by Kurumi from Date A Live and Baz Luhrmann's 1996 Romeo + Juliet) flee to "Bob-landia" and pick up a third wheel named Raw Saline (also known as Rosalind, Raw Salad, Roslan, Rossa line, etc.). Written in iambic pentameter, with trochaic tetrameter for the "Soliloquy of doom / death" rants from Juliet.

If you read the post above and then read this list, you may notice that I have personally committed nearly every sin I described. The Bob fics have no attention to craft at all (imagine an unindented, unreadable, Python program that somehow still runs). Improvised Shakespeare keeps the meter, then gets distracted by Baz Luhrmann before becoming completely unrecognizable. Elari Celestium inherited Kokomi's name, the existence of ley lines, one random cave on Watatsumi, and left (See footnote 1). And finally, Ingram actually did a good job for once.

I think that's actually the lesson. Honoring an inherited system is the harder version of the work, and the temptation to ignore it is constant. The fact that I know this and still wrote Improvised Shakespeare is not a contradiction — it's the point. You learn the discipline by violating it, getting yelled at, and slowly figuring out which violations were worth it.

Which, again, is just engineering with worse prose.