What if the messiest part of your work—the false starts, the debugging, the half-formed ideas—was exactly what people wanted to read?

I used to think content creation had two phases: do the work, then document it. Build the system, then write the tutorial. Fix the bug, then explain the fix. The documentation was always a separate, polished artifact that came after.

Working with AI changed that. The conversation is the work. And that conversation—complete with wrong turns and iterative refinement—is more valuable than any sanitized summary I could write afterward.

WHY: The Documentation Tax

Traditional content creation imposes a tax. You finish a project, then you have to remember what you did, organize your thoughts, and translate the messy reality into a coherent narrative. This tax is high enough that most work never gets documented at all.

Think about your last debugging session. You probably learned three things worth sharing. But by the time you fixed the bug, you were tired, and the idea of writing a blog post felt like starting a second job. So the knowledge stayed in your head, where it will slowly evaporate.

The documentation tax kills content at scale. Every developer has years of accumulated insights that never make it out of their brain because the act of formalizing knowledge feels like extra work on top of already-completed work.

HOW: Work as Documentation

When you work with an AI assistant, something different happens. Your thinking is already externalized. The prompts you write, the clarifications you make, the decisions you explain—it’s all captured in the conversation.

This creates an opportunity: instead of documenting after the fact, you can treat the work itself as documentation-in-progress.

Here’s what that looks like in practice:

Traditional approach:

1. Build feature (scattered notes, mental model)
2. Later: try to remember what you did
3. Write documentation from memory
4. Result: sanitized, often inaccurate

Process-as-content approach:

1. Build feature with AI (conversation captures everything)
2. Extract the interesting parts
3. Light editing for clarity
4. Result: authentic, complete, accurate

The conversation contains the false starts that reveal common pitfalls. It includes the “why” behind decisions, not just the “what.” It shows the iteration that led to the final solution—which is often more instructive than the solution itself.

WHAT: Content Multiplication

One work session can generate multiple pieces of content:

The original conversation might include:

• A system design prompt that worked well
• An unexpected bug and its investigation
• A design decision with tradeoffs discussed
• A pattern that could apply elsewhere

Each of these is a potential blog post, extracted from work you were doing anyway. You’re not creating content on top of your work—you’re harvesting content from within it.

This blog exists because of this principle. I wasn’t planning to write about “how to capture content seeds.” I was building a system to capture them. The conversation about building the system became the first post about the system. Meta-recursion in action.

Authenticity Over Polish

Readers can smell sanitized content. The perfectly structured tutorial that makes everything look easy? It teaches the solution but hides the struggle. And the struggle is where the learning happens.

When you publish process-as-content, you’re showing:

• Real problems, not hypotheticals
• Actual debugging, not reconstructed debugging
• Genuine confusion followed by genuine understanding

This authenticity builds trust. It also helps readers who are stuck in the same place you were, using the same wrong mental model you had, making the same mistakes you made. They don’t need to see your polished solution; they need to see the path from confusion to clarity.

The Capture System

To make this work, you need a system that captures seeds while you work. Mine looks like this:

seeds/
├── prompts/     # Prompts that worked well (or instructively failed)
├── ideas/       # Insights that emerged mid-conversation
└── misses/      # Bugs, mistakes, wrong assumptions

The AI flags potential seeds during our conversation. I review them periodically and develop the promising ones into posts. The key insight: I’m not writing from scratch. I’m editing captured material.

When It Doesn’t Work

This approach isn’t universal. Some content genuinely requires research, synthesis, and structured presentation that can’t emerge from a work session. Reference documentation, comprehensive tutorials, and opinion pieces still benefit from traditional writing processes.

But for the vast category of “things I learned while doing other things”—the tips, gotchas, patterns, and insights—process-as-content is faster and more honest than the traditional approach.

The Takeaway

Austin Kleon wrote a book called Show Your Work. The core idea: share your process, not just your outputs. Working with AI makes this trivially easy. Your process is already captured. All you have to do is notice the valuable parts and publish them.

Stop treating documentation as a tax on completed work. Start treating work as documentation-in-progress. The conversation is the content.

This post? It started as a seed captured during a conversation about building a content capture system. The meta-recursion writes itself.