MEETING SELECT // DAY ONE OF THE TRACK

AIPOWERHOUSE

HACKATHON KICKOFF

One day. One real ticket from our own backlog. You run the whole lifecycle — SPECIFY → GENERATE → COMPREHEND — with an agent doing the typing.

RULE OF THE DAYShort talks, long labs. If I speak for more than fifteen minutes, something has gone wrong.

→ to begin · T starts lab timers

Morning

09:30TALKFrame — the sandwich, the day, the spotter's card

09:55TALKDrive — the Claude Code driving lesson

10:05LABLab 1 · First contact — calibrate on our own codebase

10:40TALKDebrief — the agentic loop · coffee

10:55TALKSpecify — prompting, grilling, checkable done

11:10LABLab 2 · Plan & grill — your ticket becomes a plan

11:55TALKDebrief — the seam

12:10BREAKLunch

Afternoon

13:00TALKGenerate — let it run, when to step in

13:10LABLab 3 · Build it — the agent types, you supervise

14:10BREAKDebrief + coffee — who intervened, and why

14:30TALKComprehend — expectation-first review

14:40LABLab 4 · Prove it, then review it — evidence, diff, cross-review

15:30LABLab 5 · Teach the factory — CLAUDE.md, today's lessons kept

16:00LABDemo circle — show the catch, not just the ship

16:40TALKClose — the factory · the road ahead

Timeboxes are hard; done-when beats done-everything. Whatever state your lab is in when time runs out, that's what we debrief.

The model K

Every piece of work is a sandwich. You are the bread on both ends; the AI is the filling — the only loop you follow today.

Specify — you say what you want and what the rules are. A clear spec means less guessing.
Generate — the agent does the work. It writes code, tests, and edits.
Comprehend — you read it back, ask questions, and decide. This is where quality is set.
Skip Comprehend and you did not save time. You just pushed the work to later.

Metaphor: Dan Shipper, Every's podcast “AI & I”, with Kieran Klaassen. The Specify→Generate→Comprehend framing is this engagement's own adaptation.

YOU · BREADSPECIFYsay what you want, and the rules

THE AGENT · FILLINGGENERATEcode, tests, edits — the typing

YOU · BREADCOMPREHENDread it back, question it, decide

What changes for you

REVIEW 15%

WRITING CODE 70%

SPECIFY 15%

Before

→

COMPREHEND 40%

CODE 20%

SPECIFY 40%

Toward

You write less and less code over time. The time does not vanish — it moves to the two human ends.

!

Comprehension debt

Code that ships, but nobody understands. The cost hits the first time it breaks.

!

Orchestration ceiling

One reviewer behind many agents. Past your limit, quality quietly drops.

BLOCK 3 / 6

Agree the what before anything builds.

The front of the sandwich. Vague in, vague out — judgment goes in here, while changing your mind is still cheap. Unclear requirements are this company's single biggest source of delay; this block is the antidote.

03

Block 2 · Drive — the driving lesson S

Your tool for the day: a session, your repo, and control over what it may do.

Start it in the repo root. Now it can see your real code.
Permissions: it asks before acting, until you choose to let it run.
Talk to it in plain language. Point at real files. No magic words.
Esc interrupts at any time. You are always the one in charge.

you@meetingselect : ~/platform

LAB 2 · HANDS ON · 45 MIN

Your ticket becomes a plan so clear someone else could build it.

[1]

Make it interview youpaste the grill prompt; answer at least five rounds

[2]

Get the plan + done-when list3–5 checks that can pass or fail

[3]

Swap plans with your pairmark every spot where you'd have to guess

[4]

Fix the vague spotsuntil your pair signs off

Stretch: two competing approaches from the agent; one sentence on why you chose yours.

LAB TIMER

45:00

T START / PAUSE · R RESET

You're done when

Your pair says: “I could build this without asking you anything.”

⛔ HOLD POINT — nobody builds before lunch. That urge you feel right now is what today is about.

⏸ Debrief · what you just watched

It read, it ran, it looked at the result, and it went again. That loop is the difference between an agent and a chatbot.

Each step is a tool call. The result decides the next step.
It acts — it doesn't just answer. That's what makes it wave 2.
The loop stops when the goal is met, or when it needs you.

PROMPT→ TOOL CALL→ RESULT→ REPEAT ⟳

agent — live loop

agent — session 02:41 · long run, many files

›

CONTEXT 34%

⏸ Intermezzo · taught when it happens

Long session, many files — and the answers went vague. The context window is nearly full. This is normal; now you know its name.

The agent's short-term memory has a hard limit. Old details fall off or blur.
The fix: compact the session, start fresh, or write the state to a file first.
Long runs are managed, not endured. This is half of what supervision means.

D replays the demo

The model, at scale

Many agents can work at the same time. But only one person reviews. That is the slow part.

Agents spread out. Many tasks generate at the same time.
Human review is the one slow step. It sets how fast the factory really goes.

Run more agents than you can read and you don't go faster — you just approve without checking.

htop — the factory · one human on shift

AGENTS0 / 12 running

REVIEW1 human · 100% · SATURATED

PID USER CPU% ST COMMAND

Today was the whole sandwich, fast. The next sessions slow it down — each one takes a station you ran today and builds it properly, with homework on real tickets in between.

S1/Planning & refiningThe front of the sandwich, done right: codebase archaeology, codifying tacit knowledge, the grill, the seam.

S2/Building the machineParallel agents, autonomous routines, self-reviewing pipelines, guardrails — the factory itself.

S3/Reviewing codeKeeping your grip as volume rises: architectural review, agents in the browser, blocking the rubber stamp.

S4/Orchestration & judgmentThe capstone: your parallel ceiling, backpressure, and the judgment no agent replaces.

Everyone drove an agent through Specify → Generate → Comprehend on our own code — and the lessons you wrote into CLAUDE.md are still here tomorrow. That loop, repeated, is the factory.

The harder parts — many agents at once, autonomous routines, real review at volume — come in the next sessions. We are not learning a tool. We are building a factory the team owns. Today was day one.