Artifact-Driven AI Creation

I usually use AI Agents to write code. I've spent the last few weeks using AI agents to create other documents for writing and beyond. I started by writing a chapter on meatballs - a food that emerged through history across great distance and time. That turned into a book, a slide deck, and invaluable learnings for creating with AI.

If you've ever iterated on the same document multiple times, you've probably experienced a similar frustration. You spent an hour getting it to use exactly the right voice. The structure is tight, the narrative flows, the tone is close enough to your own, so it doesn't sound like AI. You close the session.

The next morning you open a new one, ask it to revise the introduction, and you get back something that sounds like it was written by a different person. Because, effectively, it was.

This is a common failure mode in AI-assisted content creation. The outputs aren't bad. They just don't remember anything. Every session starts from zero. The AI has no memory of the decisions you made, the tone you established, or the direction you chose. So it guesses. And you spend the first twenty minutes of every session re-establishing context that should already be there.

There's a fix. It's not a better prompt. It's a better project structure.

Two Structural Mistakes

Most AI workflow failures (writing, presentations, docs, anything) come from one of two problems:

Entanglement. Your content and your formatting live in the same file. Think of a long Google Doc where the prose, the section headers, the footnotes, and the inline formatting are all fused together. When you ask an AI to "make the opening punchier," it has to navigate the entire structure and risks breaking something unrelated. The bigger the file, the noisier the edit.

Amnesia. Nothing persists between sessions. The AI produced a great draft, but the reasoning behind it (why you cut the second section, why you chose that opening, what tone the stakeholder preferred) lives in a conversation thread that's already gone. Next session, you relitigate all of it.

These aren't AI problems. They're information architecture problems. And they have known solutions.

The Fix: Artifact-Based Workflows

The core idea is simple: give the AI a project to read, not just a prompt to respond to.

An artifact is just a file with a job. A brief holds your intent. A decisions file remembers what you've tried. A draft reflects the current best version of the work. Instead of opening a session and saying "write me a blog post about X," you open a session where the AI reads these artifacts and picks up exactly where the last session left off.

This is spec-driven development applied to content. Software teams don't start coding without a spec. They don't throw away the architecture doc between sprints. The same discipline works for any iterative creation.

Three moves make this work:

1. Separate content from rendering. Your document's substance (the arguments, structure, key points, supporting evidence) lives in a content file (Markdown, YAML, whatever suits it). The formatted output is produced from it. When you want to iterate on what the piece says, you edit the content file. When you want to iterate on how it looks, you change the formatting separately. The AI never has to wade through presentation markup to sharpen an argument.

2. Make a brief the source of truth. Before you write anything, write a brief: audience, angle, tone, structure, what to include, what to exclude. This is your spec. The AI reads it at the start of every session. It doesn't guess your audience. It doesn't invent a tone. It reads the brief and writes accordingly. The brief is a living document. It gets sharper as you learn what works. And yes, the AI can help you write it: start with a rough description of what you want to create, and ask the AI to draft the brief for you. Refine from there.

3. Capture decisions, not just outputs. When you decide to cut a section, log why. When you choose a specific framing, note the alternatives you rejected. This decisions file is the AI's institutional memory. Without it, the AI will suggest the same cut section next session, or revert to a framing you already tried and abandoned. You don't have to log these manually. Tell the AI to update the decisions file when you make a call, and it will.

What This Looks Like

This post was written using exactly this approach. Each project gets its own folder. Here's this one:

blog-post/
  brief.md              ← audience, angle, tone, structure
  draft.md              ← the working post (what you're reading now)
  decisions.md          ← editorial calls with rationale
  source-material.md    ← the raw ideas this post draws from
  readme-from-gist.md   ← the .md linked at the bottom of this article

Every session starts by reading the brief and decisions. The AI doesn't guess the voice. It reads the spec.

What does a session look like in practice? You open a new conversation, point the AI at the project folder, and say "read the brief and decisions, then help me tighten the opening section." The AI reads your files, understands where the project stands, and works from there. No preamble, no re-explaining.

The concrete details matter. When we decided to focus on documents rather than slide decks as the primary example, that went in the decisions log with the rationale. When we cut an overly academic phrase, that went in too. Without this file, the next session might reintroduce the slide deck framing or re-suggest the phrasing we already rejected.

The source material is a fixed snapshot of the design principles this post draws from. Where the brief is prescriptive (what to do), source material is informational (what to draw from). It's the anchor that keeps the AI grounded in your original ideas even as the draft evolves.

The structure scales. For a whitepaper, add a sources.md for references and an outline.md that locks the section flow before drafting begins. You don't need to reconfigure anything. Just add the files to the folder and tell the AI they're there.

For a novel, it becomes essential. Character sheets, plot outlines, chapter summaries, a voice guide, a continuity log. Without this structure, the AI drifts. Characters change personality between sessions, subplots get dropped, the voice shifts chapter to chapter. With it, session forty picks up the same threads that session one established. The longer the project, the more the structure pays for itself.

Artifacts That Improve Over Time

Not every artifact ages the same way.

The brief sharpens. Early on it's rough: "blog post about AI workflows, casual tone." By session five, it specifies the audience's technical level, the points that must land, and the phrasings to avoid. You learn what constraints actually matter by writing against them.

The decisions file accumulates. Each entry is a judgment call you never have to relitigate. By session ten, it's a dense record of what you've tried, what worked, and what to stop suggesting. It's institutional memory for a project of one.

The source material stays fixed. That's its job. It keeps the AI grounded in your original ideas even as the draft evolves around them.

The draft converges. Each pass is informed by a sharper brief, a longer decisions log, and the same stable source material. The tenth revision isn't starting over. It's building on everything the other artifacts captured.

The test is simple: can a new session, reading only the project files with no conversation history, pick up where the last session left off without re-making the mistakes of the sessions before?

If yes, your artifacts are working. If no, you're still sprinting.

Getting Started

You don't need special tooling to start. Create a folder. Add a brief. Start logging decisions. The structure does the work.

A practical starting point for any content project:

Write the brief first. Before any drafting. Audience, angle, tone, structure, constraints. This is your spec. Not sure where to start? Ask the AI to interview you about the project and draft a brief from your answers.
Keep your content separate from its final format. The words and structure should live in their own file, independent of whatever formatting or presentation layer comes later.
Log decisions as you make them. Not in conversation, in a file that persists. Future sessions will thank you.
End each session with a deposit. Ask: what does the project know now that it didn't know when this session started? If the answer is nothing, the session was wasted.

Drop the md file linked below into an empty project folder. Describe to the agent what you want to build and ask it to review the document before recommending an artifact-based workflow. Within two or three sessions, you'll feel the difference: less re-explaining, less drift, more time spent on the work that actually matters. By session ten, you won't go back.

https://gist.github.com/mann-abe/3e456c193652fecd21069239034b6943