Reach / Grasp / Outgrow: the pattern behind my projects

People tolerate a shocking amount of friction simply because it’s familiar.

They call it “process.” They build roles around it. They normalize the lag, the rework, the handoffs, the spreadsheets, the “we’ll circle back.” Eventually the chaos becomes part of the identity.

That’s usually the moment I’m interested.

Reach: find the broken loop

Most problems aren’t “missing features.” They’re broken loops.

A loop is: input → decision → action → feedback. When loops break, humans patch them with memory, manual work, and meetings.

You can spot a broken loop by the sound of it:

“Just email me when you get a chance.”
“We track that in a sheet somewhere.”
“I think she handles that, but she’s out today.”
“It’s not urgent… until it is.”

The work starts by seeing the loop as a loop—not as a pile of tasks.

Grasp: make it real end-to-end

A lot of people can describe the solution. Fewer people can deliver it in a form that survives reality.

Reality includes:

incomplete inputs
edge cases
shifting constraints
busy users
incentives that don’t match the org chart
the “last mile” nobody wants to own

So the bar isn’t “it works.” The bar is:

it reduces ambiguity
it’s hard to misuse
it keeps working on bad days
it gets better with volume, not worse

That’s why I build end-to-end. Not because it’s romantic. Because handoffs are where intent goes to die.

Outgrow: turn the one-off into infrastructure

If you ship a thing once, congratulations. If you can ship the next thing with half the effort and twice the quality, now you’ve built something valuable.

Outgrow is when a product stops being a project and becomes a machine.

That happens when you:

extract patterns
encode them as primitives
build reusable scaffolding
make “good” the default

This is the Formulate mindset: build the engine, then build the car. And keep the engine.

A concrete example: referral intake vs. referral operations

A clinic receives referrals all day. Fax. PDFs. Portals. Phone calls. Missing info. Wrong diagnosis. Wrong location. Urgent cases buried in noise.

The naive framing is: “we need software to intake referrals.”

The real loop is:

referral arrives (input)
triage (decision)
route + schedule + request missing info (action)
outcomes: appointment made, info gathered, patient seen, revenue captured (feedback)

When that loop breaks, staff become the glue. Heroics fill the gap. “Experienced coordinators” become a dependency.

If you repair the loop, the clinic gets:

shorter time to appointment
fewer dropped referrals
less staff burnout
safety improves because urgency isn’t a guessing game

That’s Reach → Grasp → Outgrow:

Reach: see “intake” as a broken loop
Grasp: build the system that handles messy inputs and real constraints
Outgrow: turn triage/routing/requests into reusable engines, not one-off rules

What I believe

Systems beat willpower. If a process requires heroics, it’s not a process.

Velocity matters, but only when quality is the default.

“Clarity” is a feature. Ambiguity is hidden cost.

Infrastructure is what turns a win into a runway.

The last mile is where products become real—or irrelevant.

What this looks like in practice

When I’m building something, I’m usually doing some version of this:

Name the loop. What’s the input, decision, action, feedback?
Identify failure modes. Where does it break today, and what does that cost?
Design the primitives. What are the smallest reusable units that solve it?
Ship the smallest complete loop. Not MVP as “half a thing”—MVP as “a loop that closes.”
Instrument it. If you can’t measure it, you can’t improve it.
Extract patterns. Every repeat becomes a reusable module.
Build the engine. Make the next product cheaper, faster, cleaner.

If you’ve heard it said that man’s reach exceeds his grasp, that’s true. But in practice, I’ve found the opposite is more dangerous: people’s grasp exceeds their imagination. They can build far more than they think—once they stop accepting broken loops as normal.