Software Engineer Turned Novelist Writes Books Like Code

A software engineer's viral Hacker News post is sparking debate about whether coding methodologies can fundamentally improve the craft of writing fiction. The 'Show HN' submission details how one developer applied agile workflows, version control, modular architecture, and iterative development to write a complete novel — and the results are turning heads in both the tech and literary communities.

Key Takeaways

• Software engineering principles like modularity, refactoring, and version control translate surprisingly well to long-form fiction writing
• The developer used Git for manuscript version control, enabling branching storylines and fearless editing
• An agile-inspired sprint system broke the daunting 80,000-word goal into manageable 2-week iterations
• AI-powered tools like GPT-4 and Claude served as brainstorming partners — not ghostwriters
• The project took roughly 14 months from concept to completed manuscript, compared to the industry average of 1-3 years
• Community response on Hacker News has been overwhelmingly positive, with 300+ comments in the first 48 hours

Treating a Novel Like a Codebase

The core insight is deceptively simple: a novel is a complex system, just like software. It has dependencies (plot threads), interfaces (character interactions), modules (chapters and scenes), and bugs (plot holes). The developer argues that engineers already possess the mental frameworks to manage this complexity — they just need to recognize the parallels.

The manuscript was organized in a monorepo-style directory structure, with separate folders for world-building documents, character sheets, plot outlines, and individual chapters. Each chapter functioned like a module with clearly defined inputs (what the reader knows entering the scene) and outputs (what the reader should know or feel leaving it).

This approach stands in stark contrast to the traditional 'pantser' method — writing by the seat of your pants — which many novelists swear by. Unlike the freeform creative process championed by authors like Stephen King, this engineer treated uncertainty as a risk to be mitigated through upfront architecture and planning.

Git for Manuscripts: Version Control Meets Creative Writing

Version control proved to be the single most transformative tool in the process. The developer used Git to track every revision of the manuscript, creating branches for experimental storylines and using commit messages to document creative decisions.

One particularly clever technique involved creating a 'dev branch' for risky narrative experiments. Want to kill off a major character in chapter 12? Branch, write the death scene and 3 subsequent chapters, then evaluate whether it works. If it does, merge. If not, the original timeline remains untouched.

This eliminated what the developer calls 'deletion anxiety' — the fear of cutting text that took hours to write. With Git, nothing is ever truly lost. Every discarded paragraph lives in the commit history, recoverable at any time. The final manuscript went through 847 commits across 14 months, with roughly 40,000 words cut during the editing process — all preserved and searchable.

Traditional writing tools like Microsoft Word and Google Docs offer rudimentary version history, but nothing approaching the granularity and branching power of Git. Tools like Scrivener come closer with snapshot features, but still lack the branching workflow that makes Git uniquely powerful for exploratory creative work.

Agile Sprints for Chapter Production

The developer adopted a modified Scrum framework for the writing process. Each 2-week sprint had a clear goal: draft 2 chapters, revise 1 previously drafted chapter, and resolve at least 3 items from a 'plot hole backlog.'

A personal Kanban board in Notion tracked every scene through 5 stages:

• Outlined — scene structure and beats defined
• Drafted — first pass written, rough and unpolished
• Revised — second pass with focus on prose quality
• Beta-read — sent to trusted readers for feedback
• Final — incorporated feedback, ready for publication pipeline

Daily writing sessions replaced daily standups. Each session began with a 5-minute review of yesterday's output and a clear objective for the current session. The developer tracked velocity in words-per-sprint, averaging roughly 6,000 words per 2-week cycle — a pace that proved sustainable without burnout.

Retrospectives happened at the end of each sprint. These self-reviews identified process improvements: adjusting the writing environment, changing the time of day for creative work, or modifying the outline when a character's arc felt forced.

AI as a Brainstorming Partner, Not a Ghostwriter

The role of large language models in the process deserves special attention. The developer used GPT-4 and Claude 3.5 Sonnet extensively — but with strict boundaries. AI never wrote prose that appeared in the final manuscript.

Instead, AI served 4 specific functions:

• Brainstorming — generating 20 possible plot directions when the author felt stuck, then selecting and adapting the most promising ideas
• Consistency checking — feeding character descriptions and timelines to the model and asking it to identify contradictions
• Research acceleration — quickly gathering background information on historical periods, geographic settings, and technical details relevant to the story
• Dialogue testing — running draft conversations through the model to check whether character voices remained distinct and authentic

This mirrors how many professional software engineers use tools like GitHub Copilot — as an accelerant for routine tasks, not a replacement for architectural thinking. The creative decisions, the prose style, the emotional core of the story — these remained entirely human.

The developer estimates that AI tools saved roughly 100 hours across the project, primarily in research and consistency checking. At an estimated value of $50/hour for creative labor, that represents approximately $5,000 in time savings.

The Refactoring Mindset Changes Everything

Perhaps the most profound insight from the project is how the refactoring mindset transforms the editing process. Engineers are trained to view refactoring as normal and necessary — improving code structure without changing its behavior. Most writers, by contrast, view revision as painful, even traumatic.

The developer approached editing as pure refactoring. A scene that conveys the right information but feels clunky? Refactor the prose. A character arc that reaches the right destination through an implausible path? Refactor the journey. The emotional output stays the same; the implementation improves.

This framing removed ego from the editing process. Code isn't precious. Neither is prose. What matters is whether it works — whether it delivers the intended experience to the reader, just as code delivers the intended functionality to the user.

The developer completed 4 full revision passes, each with a different focus: structural integrity, character consistency, prose quality, and pacing. This systematic approach mirrors the layered testing strategies common in software — unit tests, integration tests, end-to-end tests, and performance tests.

Industry Context: Engineers Are Flooding Creative Fields

This project reflects a broader trend of technical professionals entering creative domains armed with systematic methodologies and AI tools. The $28 billion self-publishing market on Amazon has seen a surge of technically-minded authors, many of whom bring engineering discipline to their creative output.

Companies like Sudowrite (which raised $3 million in seed funding) and Novelcrafter are building AI-powered writing tools specifically designed for fiction authors. These platforms combine elements of project management software with LLM-powered creative assistance — essentially productizing the workflow this developer built from scratch.

The literary establishment has mixed reactions. Some agents and editors welcome the influx of disciplined, process-oriented writers. Others worry that over-systematization strips fiction of its spontaneity and emotional rawness. The debate mirrors similar tensions in other creative fields, from AI-assisted music production to computational design.

What This Means for Developer-Creators

The practical implications extend far beyond novel writing. Any engineer pursuing creative side projects — podcasts, YouTube channels, game design, graphic novels — can apply these same principles.

The key lesson is that engineering discipline and creative expression are not opposites. Structure enables creativity by reducing cognitive overhead. When you are not worrying about plot consistency or version management, your mental energy flows toward the actual creative work: crafting sentences, developing characters, building worlds.

For developers considering a similar journey, the developer recommends starting with 3 tools: Git for version control, a Kanban board for workflow management, and an LLM subscription for brainstorming. Total cost: under $20/month.

Looking Ahead: The Convergence of Code and Craft

This experiment points toward a future where the boundaries between technical and creative work continue to blur. As AI tools mature and become more accessible, the comparative advantage shifts from raw creative talent toward systematic creative execution — exactly where engineers excel.

The developer plans to open-source their writing framework on GitHub, including templates for the directory structure, Kanban board configurations, and prompt libraries for using LLMs as creative assistants. An early preview has already attracted over 1,200 GitHub stars.

Whether this approach produces great literature remains an open question. But it undeniably produces completed manuscripts — and in a world where most aspiring novelists never finish a first draft, that alone represents a significant achievement. The engineering mindset may not guarantee artistic brilliance, but it dramatically increases the odds of shipping a finished product. And as any developer knows, shipping is what matters.