the artifact is the checkpoint: what we found inside a chaotic day with ai

It started as a pile. Block variations for a restaurant newsletter, sorted by vibe, then another pile. Rounds of favourites, locked one by one. Screenshots with "I don't like these double lines" on top. An ask arriving mid-task: add the email tool's real footer, for realism, and while you're at it, a new skill called send to feedback. A lab that turned into a kit, a kit that turned into an editor, an editor that turned into a skill. A hide button that already existed and that nobody could find. A test leftover that quietly brought back a block the draft had hidden.

That was one day, building the 2fifty newsletter skill with AI. We didn't plan a method. We were trying to get a newsletter out of it.

noticing

Partway through, the same shape kept coming back.

Every time things got clear, it wasn't because the chat got clearer. It was because a page was holding a decision. The locks in the lab held the style. The saved layout held the structure. The locked fields held the content. The client's comments held the approval. The done ticks held what was done.

When a decision lived only in the chat, it drifted: asked again, remembered differently, undone by the next change. When it lived in a page, the next step could start from it, and nobody had to scroll back to find it.

That's the finding. The rest of this post is what it looks like when you draw it, and what we did with it.

the loop

Drawn as a loop, it goes like this. A skill makes a designed artifact: a page you can look at and touch. A person uses that artifact to give feedback, and the feedback is captured in the artifact itself. The skill reads it and turns it into the next artifact, a little more functional than the last. Someone acts. Then again, until the whole thing is live.

Every artifact in that loop has two jobs:

• Show the work. Something a person can judge by looking, not by reading a description of it.
• Hold the decision. As data, not as chat: a lock, a saved layout, an edited field, a comment, a done tick.

The second job is the one that matters. It turns each artifact into a checkpoint: a place where a person decides, so the agent doesn't have to guess.

Here's the same day again, read through that loop. Each artifact is listed with the decision it captured.

1. Block lab. Variations of newsletter blocks, grouped by vibe. The designer locked favourites across rounds, and each new round learned from the locks until it found a middle style. Decision: the style.
2. Kit. The locked style as a set of blocks. Reorder, hide and theme them, and the result is saved as a layout. Decision: the structure.
3. Editor. The newsletter page. Every field edited, then locked. Decision: the content.
4. Client preview. The email as it will arrive. The client comments on any block, and the comments become a change list. Decision: the client's approval.
5. Export. Numbered files, in send order, to the project folder and a shared drive. Decision: what ships.
6. Upload helper. Every link, alt text and file at hand, with a done tick for each one. Decision: what's done.
7. Live. The skill goes to the team, and a public post about it goes up. Decision: it's ready.

None of those decisions lives in the chat. Each one lives in the artifact where it was made.

why the line holds

The conversation didn't get tidier, and it still doesn't. What changed is where the line is: it runs through the artifacts, not the chat.

• Each checkpoint is small. One artifact, one decision. It's easy to review and easy to undo.
• The person judges one thing at a time. Not a scroll of proposals, but one page with one question on it.
• The agent resumes from stored state. The next step reads the locks, the layout, the comments. It doesn't have to remember what someone said three hours ago, and it can't misremember it.
• Anyone can join at a checkpoint. A teammate or the client can open the current artifact and take part without reading the conversation. The client doesn't need the chat: they get a preview and leave comments on it.
• The mess is allowed. Asks still arrive mid-task, pivots still happen. They land on the next checkpoint instead of rewriting the last one.

forcing it on purpose

The second thing we found came right after the first. Once you can see the loop, you don't have to wait for it to happen. You can force it.

• The skill makes the checkpoints happen. Lab, kit, editor, preview, export, upload helper: the whole chain is packaged as a skill the team shares, so every run produces the pages that hold the decisions, instead of hoping someone makes them.
• The reflection writes the lessons into the next run. At the end of the session we looked at what went wrong and wrote it down as rules the next session starts with. Two of them: "never test against a live artifact; use a throwaway copy." And "a control that only appears on hover is missing."
• The next run starts from the process, not from zero.

So the first time is discovery. The second time is a process. And the process keeps learning, because every run ends with the same question: what should the next one know?

On our practice page we say we build to understand, because some questions only answer themselves once something is running. This is the same idea, one step further. We couldn't have designed this loop up front; we found it by building. And the understanding doesn't stay in someone's head or in an old chat. It ends up in the tool.

where it breaks

It isn't free, and we hit most of these on the same day:

• Test data can leak into a live artifact. A test ran against the real page instead of a copy, and quietly brought back a block the draft had hidden on purpose. The checkpoint held the wrong decision, and it looked right. That's where the throwaway-copy rule came from.
• A hidden control reads as a missing feature. The hide button only showed on hover, so it was reported as not existing. If a checkpoint is where a person decides, they have to be able to see what they can decide.
• An artifact that only shows is a dead end. If it collects nothing, the decision goes back into the chat, and the line breaks there.
• Checkpoints cost something. Each one is a publish and a moment of someone's attention. Too many and it turns into ceremony. One per real decision is about right.