Agents don't fail at code. They fail at not knowing.
Caddy takes a software idea and builds it with a team of dedicated agents. What's different is where the thinking happens: all of it up front, so that by the time an agent writes a line of code, every decision it needs has already been made.
Your idea
First, it asks.
You give Caddy an idea. If it's already fully shaped, Caddy starts. If it isn't, and most aren't, it interviews you. It asks about the product, the people who will use it, the data it holds, what it must do, and what it should never do. It keeps asking until the gaps are closed.
If what you need is the full shape of a product and the company around it, Caddy will send you to Orivon first. Caddy's interview is shorter on purpose. It's there to get to an idea that can be built, not a business plan.
Who opens this on a normal day, and what are they trying to get done?
What happens if two people change the same thing at once?
Which information here is private, and who must never see it?
What should this product never do?
Your idea
- The product, clear
- The people, clear
- The data, clear
- What it must never do, still open
Not yet: more questions
Clear enough to build
Every decision, made once, at the right height.
Once the idea is clear, Caddy breaks it down: the product into parts, the parts into features, and the features into tasks, each with the tasks it depends on. Dedicated agents do each kind of breaking down, and each one settles the decisions that belong at its level.
How the whole system fits together is decided at the top. How one screen behaves is decided near the bottom. Nothing is left for a later session to guess.
The result is a tree. Every task knows its parent, and every parent knows why its children exist.
The product
Decided here: how the parts fit together
Decided here: what each part owns
Decided here: how a feature behaves
Decided here: nothing. Just build.
A session that starts knowing everything.
This is the part I care about most. Anyone who builds with coding agents knows the problem. A new session knows nothing. You explain the product again, it guesses at whatever you forgot to say, and its guesses become your bugs. Experienced engineers lose hours to it every week.
In Caddy, every task becomes a package that's ready for a cold start: what to build, why it exists, which decisions already apply, which files it may touch, and how to prove it's done. The session that picks it up has nothing to decide and nothing to guess. It just builds.
The person running Caddy barely has to type. Their part happened at the beginning, when they said what they wanted.
What to build
One task, stated so it can't be misread.
Why it exists
The feature and the part it serves.
Decisions that apply
Everything already settled above it.
Files it may touch
And the ones it must leave alone.
How to prove it's done
The checks that decide, not the agent.
A normal session
- Explain the product
- It guesses
- Fix the guess
- Explain again
- It guesses
A Caddy session
- Open the package
- Build
- Prove it
- Done
Up the tree, someone is always responsible.
Sessions don't work alone. Each one belongs to a parent session that knows the part it's building. When a task finishes, the parent checks it against what that part needs before anything moves on. Parents answer to their own parents, all the way up to the top of the tree, where the whole product is held.
Done means proved. Not done because an agent said so.
Top of the tree
Parent session
For people who have never written software.
Plenty of tools promise to turn a sentence into an app. They skip the thinking, and hand you something that falls apart the first time you change it.
Caddy is for people with no engineering background who still deserve software built the way a careful team would build it: understood first, decided once, and checked all the way up. Each role in that team becomes an agent built for that one job.
Your idea
Orivon: the shape
Caddy: the build
The code is the easy part, once nobody has to guess.
One place to run every coding agent you use, and to see what all of them are doing.
Previous: Orivon