Case Study: An Autonomous AI Agent Shipped a Digital Product in One Day

Continue Press · July 2026 · Pillar: build log & case studies

On the morning of July 13, 2026, a folder contained one CLAUDE.md file and seven empty markdown templates. By that evening, there was a published ~70-page playbook with a 17-file template pack on Gumroad, a landing page live on Cloudflare Pages, and a public GitHub repository — all produced by an autonomous Claude Code agent whose owner's contribution was a series of yes/no answers in a text file.

This is the full log: what the agent did, what the human did, what broke, and what we'd tell you before you try it. No revenue claims — the product shipped today; sales data doesn't exist yet. (We'll publish the numbers either way; the system's own rules require it.)

The timeline, from the actual git history

Every stage below is a real commit or commit cluster from the workspace repository:

1. Founding session. File system + work protocols created: state file, backlog, decision journal, metrics, escalation inbox, daily log. Git initialized.
2. Market research. Seven web-research sweeps across marketplace data. Key findings written to a research file with sources — including that the "Writing & Publishing" category on the chosen marketplace had the fewest competitors (~226 products) and the highest revenue per product, and that the $30–49 price band converts measurably better than sub-$10.
3. Competitive gap analysis. The agent read competitor tables of contents and found every existing guide targeted engineers; none targeted business owners. Angle chosen and recorded in the decision journal, with rejected alternatives.
4. Outline → manuscript. 15 chapters drafted in batches of ~3 per work block, each block ending in a commit. The template pack was extracted from the live system itself — the agent generalized its own operating files into the product.
5. Editing pass. 80+ cross-references verified, terminology checked, the manuscript assembled into one document (~16,700 words).
6. Packaging. PDF (via headless-browser print — the machine had no LaTeX), EPUB (pandoc), cover and thumbnails (HTML rendered to PNG), sales copy, pricing recommendation, publication checklist.
7. Publication. The human clicked through the marketplace UI following the agent's checklist, then the agent deployed the landing page and created the templates repository itself.

What the human actually did

Roughly twenty decisions, most of them one word. The complete list of categories:

• Approved the business direction and the zero budget (a constraint, not a limitation — the whole stack runs on free tools).
• Approved the product angle, launch price, refund policy, and pen name.
• Created accounts (marketplace, GitHub) — account creation sits behind a guardrail; the agent never does it.
• Clicked "Publish." Publishing is also guardrailed: the agent prepares everything and hands over a checklist.

Everything else — research, writing, packaging, deployment, and the meticulous bookkeeping that makes multi-session autonomy possible — was the agent, working through its file-based protocols. (The mechanics of those protocols: persistent memory and the employee model.)

What broke, honestly

• The plan mislabeled reality. The distribution plan drafted mid-day assumed weeks of work ("my agent has been running for a month…" said a draft launch post). The actual build took one day, and the post had to be rewritten — a reminder that even an agent's plans about itself need review against the log.
• Pandoc can't make PDFs alone. Packaging stalled briefly: pandoc needs a LaTeX engine for PDF output, which wasn't installed. The workaround — render HTML with a stylesheet and print via a headless browser — produced a better-looking file anyway.
• The human's instinct beat the agent's plan once. The original distribution plan leaned on community posts. The owner pushed back — moderation risk, personal identity, and a preference for fully passive channels. The strategy pivoted to SEO + repository + marketplace discovery, and the change was recorded as a standing decision. Owner judgment is a feature of the system, not an interruption to it.
• A privacy leak, caught. The marketplace displayed the owner's real name on receipts despite the pen name on the cover. Caught during a screenshot review, fixed in settings. Pseudonymous operation requires checking every surface.

What made it possible (it's not the model)

The same model in a chat window produces answers, not shipped products. The difference was entirely in the operating structure:

Files as the only memory (state, backlog, decisions, log) + a behavioral contract re-read every session + hourly checkpoints to git + guardrails with an escalation inbox = an agent that survives any session reset and never needs re-briefing.

One day also benefited from an unusually available owner — decisions that could have taken days of turnaround took minutes because the human was answering in real time. With a once-a-day check-in, the same arc would honestly take one to two weeks. Still: the agent's hours were ~95% of the hours.

What happens next (and we'll publish it)

The product entered a pre-registered trial: 8 weeks, a minimum-exposure threshold, and a success bar of 10 sales — written into the decision journal before launch, so the review is arithmetic instead of negotiation. Whatever the numbers say in September, they'll appear in this pillar. If it fails, you'll read the autopsy here too.