Story of a Lifetime

Every meaningful decision in this project came from the human side. Whether this was a good agent use case. The three-agent separation of concerns. Using a dedicated API key per project. Keeping prompts outside code. The human-in-the-loop checkpoint. The world type concept and its four definitions. The original vs revised story framing. Pushing back when something felt wrong. Asking why. Knowing when to stop adding features. These are not small things — they are the project. The code is just the expression of those decisions.

The user experience was shaped entirely from the human side too — the three-column layout, hiding the facts textarea until the agent populates it, moving world type from an informational panel into an active input, removing the creativity slider when it became redundant with world type, the progressive reveal of agent controls after approval, collapsing setup cards once facts are generated to keep the interface clean, the dark About card as an elevator pitch, the punchy tagline. Every one of these was observed, questioned, and decided during the conversation — not generated.

Testing was also entirely human-driven. Every agent interaction was manually exercised across world types, contradiction levels, and story lengths. Edge cases — the Critic rejecting all three attempts, empty fact lists, very long generations — were caught and resolved through hands-on use. A unit test suite (40 tests, 7 classes) was added as the codebase matured, covering configuration, request models, result classes, prompt templates, and the zero-fact short-circuit. The decision to add tests, and the decision to refactor the flat package structure into layered sub-packages, both came from the human side — as did the direction to extract shared agent infrastructure into a base class once the duplication became visible.

Claude wrote all the Java, HTML, CSS, and JavaScript. It set up the Spring Boot structure, wired the agents together, handled the OkHttp calls, built the Mermaid diagram, generated the Dockerfile and deployment scripts, and kept the growing codebase consistent across dozens of iterations. It also pushed back where it had a view — on prompt design, agent temperature choices, and what "genuinely agentic" means versus a dressed-up prompt chain.

Partially — but not entirely. Vibe coding in its purest form is "describe what you want, accept what you get, don't worry about understanding it." That's not what happened here. The architectural decisions were deliberate and reasoned. The human understood what each agent was doing and why. When something broke, the cause was diagnosed — not just retried. The better description is AI-assisted development with genuine human judgment driving the architecture. The speed at which a working multi-agent system went from idea to production is very much the vibe coding energy. The depth of the decisions behind it is not.

The parts Claude could not contribute: knowing what problem to solve, deciding what made a demo compelling, choosing when the Critic loop was the right thing to show an audience, recognising that "append-only facts" needed rethinking when the Fact Generator arrived. The parts a human could not contribute at this speed: the Spring Boot wiring, the OkHttp timeout configuration, the Mermaid diagram syntax, the CSS grid layout, all of it produced in seconds. The collaboration worked because both sides stayed in their lane.

The Fact Generator produces facts, but the human approves them before the pipeline proceeds. This is not just a UX choice — it demonstrates one of the most important agent patterns: knowing when to pause for human judgment rather than running fully autonomously.

A single control shapes both what facts are invented and how the story is told. This keeps the two agents coherent — an outlandish fact set paired with plain literary prose would feel wrong, and vice versa.

Once approved, facts become the baseline and cannot be removed — only added to. New facts must be reconciled with all previous ones. This mirrors how real environments work and is what makes the original vs revised comparison meaningful.

A pipeline executes in sequence. An agent evaluates and decides its next step. The Critic's reject-and-replan cycle — with the rejection reason fed back into the Planner — is what crosses that line.

Fact Generator never plans. Planner never writes prose. Writer never judges feasibility. Critic never generates content. Clean separation makes each agent inspectable, testable, and independently tunable.

Model, temperature, and all prompt wording are in files — not hardcoded. Experiment freely without recompiling.

Rather than exposing a separate creativity slider, creativity is derived automatically from the world type the user already picked. Fewer controls, more coherent output — grounded → low creativity, outlandish → high creativity.

The codebase started with all classes in a single flat package — acceptable early on, but increasingly hard to navigate as the agent count grew. Rajiv directed a structural refactoring into five sub-packages: config, model, agent, result, and web. At the same time, duplicated infrastructure across all five agents (OkHttp client setup, prompt loading, Claude API call, cost calculation) was extracted into a shared BaseAgent class, and the four common fields on every result class were pulled into a shared AgentResult base. Zero behaviour change — purely structural, with all 40 unit tests passing before and after.

JUnit 5 via spring-boot-starter-test. All tests run without an API key — they test only local logic, not live Claude calls. The factCount=0 short-circuit in FactGeneratorAgent makes it possible to exercise the agent class itself without any network call.

Coverage: AppConfig defaults and story length parsing · WorldModel constructor and getters · CriticResult APPROVED/REJECTED decision logic · FactGenerateRequest field defaults and setters · all five agent result classes · every prompt template file (exists + all required placeholders present) · FactGeneratorAgent zero-count short-circuit.

Every agent interaction is exercised against the live Claude API across world types, contradiction levels, and story lengths. Edge cases — the Critic rejecting all three attempts, empty fact lists, very long generations, the 0-fact path — are caught through hands-on use. The feedback loop between running the app and directing the next change is where most of the product quality came from.