Friday to Sunday

A colleague of mine had been thinking about a product for a while. He works in insurance and had identified a gap in the market, a problem that the industry had been working around for decades but nobody had really solved well. He'd been sketching out architectural designs and use case scenarios on his own, trying to get the idea into shape.

I'd been telling him about agentic development, and he was curious but skeptical. So I said: let's just run your idea through the process. Give me an afternoon.

Friday: The Conversation

We got on a call. Me, my colleague, and my buddy Kevin, who's spent years in the same industry and knows the domain inside and out. I hit record on Otter and said, "Just talk. Tell me everything. Don't worry about structure or tangents. Just get it out."

And that's what we did. For about an hour, the three of us talked through the problem space, the business rules, the API interactions, the edge cases. My colleague shared his architectural designs and walked us through the use cases he'd mapped out. Kevin and I drew on our own experience with similar systems. It was the kind of conversation that, in a traditional development shop, would have been the first of about twenty meetings before anyone wrote a line of code.

Then came the part that made him a little nervous.

I fed the transcript into Claude and started building the PRD. Product requirements document. Claude asked clarifying questions. Good ones. Specific ones. About twenty-two of them. Around question twelve, my colleague asked what I'd been waiting for:

"Is this going to be like dealing with an offshore team? Where the questions never end?"

I said no. These questions will end, and they're all pertinent. Every one. Claude wasn't confused. It just didn't want to guess. It was asking about who the users were, what the workflow looked like, how the business rules should be structured, where the data needed to flow. These were real questions. The kind that, if you skip them, you rebuild half the product three months later.

By end of Friday, we had a PRD and a structured backlog. Milestones, stories, vertical slices. He looked it over and said it was solid. Then came the question: "How long will this take?"

Kevin and I both laughed. I said, "Probably Sunday. But let's plan on giving you a SITREP Monday morning, just so I don't oversell it."

He didn't believe us.

Saturday: The Build

Saturday morning, I set the development bot running on the first milestone. This was the first time I'd used a milestone-based approach instead of building the whole thing in one pass, and it turned out to be exactly the right call.

The first milestone got me the core. The main data structures, basic CRUD operations, the API layer. I could log in, poke around, see what the thing actually looked like before it got complicated. Pushed it out, set up CI/CD (all through Claude, me directing instead of writing code), ran tests. Then I moved to the next milestone.

Second milestone. Third. At each stop I could see the product coming together, pull back if something wasn't right, make sure the new code didn't break what was already there. This feels completely different from watching a team grind through a sprint for two weeks, hoping the demo doesn't explode.

Sunday: The Finish

By Sunday morning, everything was done except the last set of stories. I kicked off that final milestone before heading to church. On the way home, my wife needed to stop at a couple of stores. I sat in the parking lot, checked my phone, and the build was done. Tests passing. Last milestone complete.

Friday afternoon to Sunday morning. From a conversation to a deployed, tested application with a CI/CD pipeline.

And we didn't just build it. We built it right. Milestones, tests at each stage, API-first architecture so his clients could integrate programmatically. The kind of structure that takes weeks to argue about in a traditional project before anyone even opens an IDE.

What Changed

Here's the thing. The tech side is interesting but not the point. The economics are.

His idea was solid. It hit a real pain point in an industry where people have been limping along with spreadsheets and legacy systems for decades. Under the old model, hire a team, staff a project, run sprints. The cost to validate this would be six figures minimum. Probably more. The kind of investment that kills most ideas right out of the gate.

What we did over one weekend would have taken a traditional team weeks, maybe months, and required a project manager, a tech lead, two or three developers, and someone to manage the infrastructure. Instead, it was three guys on a call, one afternoon of requirements, and a weekend of directed agentic development.

That's not a marginal improvement. That's a category change. Ideas that were previously too expensive to even prototype are now buildable over a weekend for the cost of an API subscription. The person driving it doesn't have to be a developer. They need to understand the problem deeply enough to direct the machine.

I told him the email would go out Monday morning. It did. With a URL, login credentials, and full documentation.

He still doesn't quite believe it happened that fast.

← Back to Blog