Starting With a Vague Need
Every program I have started began as a sentence I could not yet turn into a process. "We should track this better." "Someone needs to own this." The sentence names a discomfort and leaves the design open. Nothing about it says who does the work, where the work arrives, or how anyone would know it is done.
My first conversation with Claude on a new program is unstructured. I describe the discomfort in my own words and ask Claude to restate it as a problem statement. The restatement is usually close and slightly wrong, and correcting it takes a few rounds. After those rounds I have one paragraph that names the problem and the people affected. That paragraph is the only artifact of the first hour.
Naming the Work
Next comes a short set of questions that Claude asks and I answer. Who does this work today? What starts it? What does done look like? The answers go into a few plain sentences.
Some questions have no answer yet. Those gaps become the first things to resolve, and finding them early is the purpose of the exercise. A program with an unanswered "what starts it" will stall at its first real request.
A Hypothetical Walkthrough
Take a made-up program: a team receives requests from other teams and wants a consistent way to handle them. The vague sentence is "requests keep getting lost." The problem statement says that requests arrive through several channels, and nobody can say how many are open.
The answers to the three questions come out as follows. One person handles requests today. A message from another team starts the work. Done means the requester has an answer and the answer is recorded. Intake becomes a single form with three required fields. Review has one named reviewer who accepts, rejects, or asks for more. Every accepted request gets an owner and a next date. A weekly pass looks at everything still open. The whole design fits on one page, and every part answers a gap that the questions exposed.
Intake
Every program needs one place where work enters. That place can be a form, a request queue, or a designated inbox. The rules are short: one entry point, a small set of required fields, and a way for the submitter to see that the request arrived.
Claude drafts the fields and I remove any field I cannot explain a use for. A field with no use costs the submitter time and returns nothing to the program. I add fields later when a repeated question shows that the program needs them.
Review
Once work enters, someone looks at it. The design needs three decisions: who reviews, what the review can decide, and what the review records. A review can accept an item, reject it, or ask for more information. Each outcome gets a written reason, so a later reader can follow the decision without asking anyone.
I start with one named reviewer. Backups and rotations come after the first few real items show what the reviewer's day looks like.
Ownership
Every item leaves review with an owner and a next date. The owner is a person, and the date says when the item next needs attention. An item without both drifts, because nothing tells anyone to look at it again.
Claude and I test this rule with a hypothetical item. We ask who moves it next and when. If the answer takes more than a sentence, the design changes until it takes one.
The Recurring Check
A program that only reacts to submissions stops when the submissions stop. A recurring check reviews what already exists on a schedule: a periodic pass over open items and a periodic look at past decisions. The cadence follows how fast the work changes. Fast-moving work gets a short interval and slow-moving work gets a long one.
The cadence gets written down and placed on a calendar or a scheduled task. This step is easy to defer, and deferring it produces the staleness described in the previous post. A daily report from an overseer agent covers the gap between recurring checks, and the checks themselves stay with a person.
Running It Before Documenting It
I run the smallest version of the program on one or two real items before writing much down. Documentation written after a run describes what happened. Documentation written before a run describes what someone hoped would happen, and the two rarely match.
Where Claude Fits
Claude does four things in this process. It asks the questions that expose gaps. It drafts intake fields, review outcomes, and the one-page description. It tests the design by walking hypothetical items through it. It rewrites my rough notes into clean text on request. I supply the context about the organization and make every decision. The design reflects my choices, and Claude's drafts give me something concrete to accept, change, or reject.
What Comes Out
The result is a one-page description with five parts: the problem, the entry point, the reviewer, the ownership rule, and the cadence. Everything else gets added later, one piece at a time, when a repeated need shows up. A program at this stage is small enough to explain in a few minutes and complete enough to run.
The next post covers what keeps a running program from going stale, and compares continuous and periodic review.