Let’s be honest—design has always been the Achilles’ heel of most teams. How many times have you sat through mind-numbing design reviews, watching weeks slip by, only to end up with a bloated document that no one reads and a half-baked implementation that still needs constant rework?

At Voice of Reason, we asked ourselves a bold question: What if we could throw out the old process altogether? Instead of sprawling, unfocused teams where everyone plays a small part in an endless relay, we built lean, two-person teams—what we call two-sandwich teams—backed by powerful AI. The result? We can do the work of seven people in one-tenth the time. No exaggeration.

The outcome isn’t just documentation or a pile of vague design diagrams—it’s working code. Code you can cut, paste, and run.

Where Traditional Teams Fail

Here’s the harsh truth: most teams waste time on documentation that gets outdated before implementation even begins. They spend weeks in design meetings, debating minutiae, and often end up with a brittle solution that lacks cohesion.

The reason? Design by committee doesn’t work. When too many hands touch the process, the result is rarely elegant. Worse, when developers finally start coding, they realize half the design doesn’t fit the real-world constraints of the system. More meetings follow, timelines stretch, and morale drops. Sound familiar?

We decided to stop that madness.

The Aggressive, AI-Driven Alternative

At Voice of Reason, we’re building life-changing technology—AI tools that empower people with dementia, learning disabilities, or traumatic brain injuries to live independently. To meet this challenge, we adopted a hyper-aggressive design and implementation process powered by AI and driven by two-person teams with laser focus.

Here’s how we do it:

1. Start with a Custom AI Assistant (Our Own GPT)
We created a custom GPT using tools like OpenAI’s GPT Creator. The setup process is straightforward:

    • First, we load a single file containing the entire codebase. Yes, one massive file. Why? Because AI doesn’t care about our human need to organize code into multiple files—it processes the entire thing as one cohesive dataset. This approach avoids the GPT’s file count limit as long as the file isn’t too big.
    • Next, we feed in two critical sets of documents:
      • Example notebooks and API references. These give the GPT context on how we write code and interact with external systems.
      • A tightly written requirement document for the feature we’re adding. This document avoids any design suggestions—it’s purely about what needs to be done, not how.

2. Challenge the GPT, Don’t Just Ask for Code
We don’t start by asking the GPT to write code. That’s a rookie mistake. Instead, our first prompt is always the same:
“Analyze the requirements and propose a design.”
The GPT provides a design proposal, which we then challenge and refine. We ask probing questions like:

    • “How would this fit with our existing ContextManager class?”
    • “We already use Chroma for vector storage. Can you adjust the design to leverage that instead of SQL?”​​
    • We push the AI hard, iterating rapidly until we get a design that’s solid—not just theoretically, but in terms of actual integration with our existing system.

3. Demand an Implementation Plan, Not Code
Once the design looks good, we ask the GPT for an implementation plan. And we’re very clear:
“Let’s not worry about code examples yet. Just give us a plan that integrates seamlessly with our current architecture.”
This step is crucial. It prevents premature coding and ensures we have a clear roadmap before touching a single line of code.

4. Only Then, Generate Code—That Works Out of the Box
Finally, when the plan is rock-solid, we tell the GPT to implement specific parts of the solution.
And here’s the kicker: the code it produces is often ready to run immediately. No major rewrites, no endless debugging sessions. Just clean, functional code that matches our architecture and standards.

Speed vs. Quality? Why Not Both?

Most teams believe you have to choose between speed and quality. They assume that moving fast means cutting corners. But we’ve proven otherwise. By combining AI with an intense, focused, two-person process, we move faster and deliver better results.

Think about it: two people, with the right guidance and an AI assistant, can produce a complete feature—from requirements to running code—in a single day. That’s a fraction of the time it takes most teams to even agree on a design document.

The secret? Intensity and clarity. It’s not about piling on more bodies or man-hours—it’s about pushing hard, making rapid decisions, and iterating aggressively.

The Real Challenge: Can You Handle the Pace?

This process isn’t for the faint of heart. It’s intense, it’s fast, and it demands sharp focus. But if you’re tired of wasting weeks on design-by-committee, and if you’re ready to deliver real, working solutions in days instead of weeks, this method can revolutionize your development workflow.

You won’t just outpace larger teams—you’ll embarrass them.

So, here’s my challenge to you: Try it. Form a two-sandwich team. Pick a feature, set up a custom GPT, and follow our process. Push the AI hard, iterate quickly, and see how far you can get in a single day.

I guarantee you’ll be shocked by what’s possible.

After all, as Steve Jobs once said,
"Simple can be harder than complex: You have to work hard to get your thinking clean to make it simple. But it’s worth it in the end because once you get there, you can move mountains."

Ready to move mountains?