McCloskey.ai · ResourcesAll resources
← Resources The method, as a route

The 4D Build

One idea in, one real thing out. A skill you run to drive a single idea from a fuzzy thought to a finished thing, checkpoint by checkpoint, without stalling halfway.

Adapted from the AI Fluency framework by Rick Dakan, Joseph Feller and Anthropic, CC BY-NC-SA 4.0. This is the doing companion to that lesson: it teaches the four Ds, this skill runs them on one real thing.

How it works

Run it like a sat-nav

A tour guide points at sights and lets you wander. A sat-nav names the destination, calls each turn, and does not let you pass a checkpoint until the thing that checkpoint produces exists. This skill is the sat-nav.

  • Name the destination: the one shippable thing, and keep it in view.
  • Take each turn as it is called, one question at a time.
  • Hold the gate: no checkpoint is passed until its output exists.

It opens with one question: what do you want to walk away with by the end of this session? Too big for one sitting? Shrink it to a slice that ships.

The whole drive

The route

The full chain, start to destination. The skill ticks each box out loud as you earn it, so you always know where you are on the road. Two of the checkpoints are firm gates that do not open early.

  1. Delegationpick it, and size it to one slice
  2. Descriptionbrief it, name the finish line, out comes a PRD
  3. GateNo Translator without a PRD
  4. Translatorthe PRD becomes one runnable prompt
  5. Sharpen optionala second model pressure-tests the prompt, your call
  6. ▶The Buildseparate, orchestrated, at machine speed · Mission Control watches
  7. Discernmentyou judge what came back
  8. Diligenceyou verify, sign, and ship
  9. GateNothing ships without Diligence
By the end of one run you have
  • Picked one thing to build, sized to finish today.
  • Briefed it, built it, and judged what came back.
  • Owned the result, and a short log of how you got there.

Delegation

Pick it, and size it to one slice

Choose one real thing to build, and shrink it until it fits a single session. Anchor the size: a one-page guide, a working spreadsheet, a draft web page, one web page built and reviewed.

  • What exactly do you want to walk away with?
  • Is this one session, or should it be smaller?
  • Is this a job for AI, or better done yourself?

Out of this comes one named, right-sized slice. A slice that ships beats a project that stalls. Skip it and you risk building the wrong thing well.

Not sure what to hand over? The SOP Generator has ready-made tasks to start from.

Description

Brief it, and name the finish line

Brief the task clearly enough that good work can come back. Not sure how to brief it? Let it interview you first: a big brain dump, then a few tightening questions, then you write the brief together.

  • Have you given the context, the audience, and the format?
  • Could a capable stranger act on this brief?
  • What does good look like, and what is the finish line?

The brief becomes a PRD, the one document the build sticks to. Vague in, vague out.

Cannot name what good looks like? The Translator interviews you and writes it.

Firm gate · the PRD

No Translator until a PRD exists that a capable stranger could build from. A half-built brief is what makes builds stall, so this gate does not open early. It is the whole point of the skill.

Translator

Turn the brief into one runnable prompt

Same Translator skill from the library. There it picks the level for any task; here the level is already set (you are building), so it does its other half: it turns the PRD into one big, self-contained prompt, the context, the constraints, the eval, and the deliverables all inline, so the build does not stall halfway looking things up.

  • Is everything the builder needs inside the prompt, with no lookups?
  • Are the constraints and the definition of done written down?
  • Could the builder run this without asking you a single question?

Out of this comes one complete, runnable prompt. Skip it and the build starts from a document instead of an instruction, and drifts.

This is exactly what the Translator skill does for you.

Sharpen optional

Let a second model pressure-test the prompt

Optional, and your call. Hand the runnable prompt to a second model in planner mode before any build spend. It hunts for what would sink the run: stale facts, unverifiable steps, scope creep, and rewrites the prompt sharper.

  • Is this build big or costly enough to be worth a second pass?
  • Escalate to a sharpen pass, or run it as is?
  • Which model sharpens, and which one builds?

One model sharpens, the other builds. For a small build, skipping this is fine. For a costly one, it is cheap insurance.

The Build

The machine builds; you watch it run

This runs elsewhere, not in this chat. The runnable prompt goes to a builder session with multi-agent orchestration: builders build, verifiers try to refute done against the brief, fixers fix, and the loop runs at machine speed.

  • Are the target folders pre-cleared, so the run does not stall on a permission pop-up?
  • Do you want a live view while it runs?
  • Is the prompt handed over cleanly, with nothing left implied?

The build happens off to the side; you hand the prompt over and let it run. This is the inner loop, at machine speed.

Want to see a build run live? Mission Control shows one mission fanned out to a team of agents, checks landing in real time.

Discernment

Judge what came back

Look hard at what the build returned and decide what is actually good. Do not defend the work, hunt for what is off. AI is fast, and sometimes confidently wrong.

  • Is this actually good, or just plausible?
  • What did you keep, what did you cut, and why?
  • Does it need another loop, or is it there?

Out of this comes a clear keep or cut, and a decision to loop or move on. Skip it and you ship whatever the AI happened to produce.

The detective prompt · run it on the work you just got 
Put your detective hat on and turn it on the work you just gave me.
Do not defend it. Hunt for what is off.

1. The three weakest points, most serious first.
2. Any fact, figure or name you are not fully sure of.
3. What a sharp critic would attack first.
4. One thing that is missing that I have not noticed.

Be specific. Quote the exact lines.

Diligence

Verify, sign, and ship

Own the result before it goes anywhere. Verify the claims you rely on, then put your name on it. The AI does not sign the work, you do.

  • Have you verified the claims you are relying on?
  • Can you stand behind this and explain it?
  • Is this yours now, not the AI's?

Out of this comes something verified and signed. Nothing ships that you have not put your name to.

The stand-behind-it prompt · run it before you ship 
I am about to put my name on this. Before I do:

1. List every claim a reader could challenge, and how I would back it up.
2. Flag anything that would embarrass me if it were wrong.
3. Name the one risk you would not ship without checking.
4. Tell me plainly: what have I not verified myself yet?

The final call is mine. Give me the checklist to make it.
Firm gate · Diligence

Nothing ships that you have not verified and put your name to. Like the PRD gate, this one does not open early. Your call to check it. Stand behind it.

The two loops

The engine inside the drive

The route has two loops running underneath it. Name them and you feel the work moving.

  • The inner loop runs between Description and Discernment: describe, judge, refine, go again.
  • The outer loop wraps the whole drive: Delegation opens it, Diligence closes it.

During the Build the inner loop runs at machine speed. When Diligence is signed, the outer loop closes and the next slice starts back at Delegation.

Want the full teaching on both loops? It lives on the AI Fluency lesson →

The tick-off and the handoff

The 4D log, and the baton

The skill keeps a live log and ticks each box out loud as you earn it. That visible progress is the point: it makes the drive feel like software, at no cost. It saves as a file at the close.

# 4D log: [project name] [x] Delegation: the task, sized to one slice [x] Description: the brief, and the finish line [x] PRD: the document the build sticks to [x] Translator: the one runnable prompt [ ] Sharpen: taken by which model, or skipped and why [ ] Build: where it ran, and the result [ ] Discernment: kept or cut [ ] Diligence: what you verified, where it shipped Next slice: [optional]

When a build crosses models, the handoff rides on one file: the 4D baton. It carries the live tick-off plus two pointers, the active prompt and the sharpened prompt, so no model sharpens the wrong prompt or loses what another produced. The log you read and the baton the models read are the same file.

If you forget all this

It is a roadmap, not a prison

You do not need to memorise the stations and every question. That is what the skill is for. It keeps you on track and stays out of the way.

How to use it
  • Run the skill in Cowork or Claude Code, with this page open beside you.
  • Skip any checkpoint you do not need, except the two firm gates.
  • Looped three times on the same piece with no progress? Ship it or shrink it.
Take it with you

Download the skill

One file. Drop it into your skills folder in Cowork or Claude Code, then run it any time you want to build something.

The 4D Build skill

The whole route as a skill: it drives you through the chain, holds the two gates, and keeps a short log of the build.

mccloskey-4d-build-skill.zip
Download ↓
What you learned

New to the four Ds themselves? Start with AI Fluency: the foundations → then come back and run one.

Where next

See how delegation scales up with Subagents → watch a build run live at Mission Control → or browse the rest of the resource library →