Everyone says vibe coding with Claude Code is the future. But 90% of these projects never actually go anywhere.
They start fast. They look promising. Then they hit a wall that no amount of prompting can fix. And that’s not even mentioning the backend marketing and distribution needed if the product ever becomes functional.
My name is Charles Dove, and my co-founder Chris Kahler and I figured out the one thing almost nobody’s doing. After some soul searching and a bunch of failed projects, we built the framework that fixes this exact problem. In this post, I’m breaking down everything we showed on our Charlie Automates YouTube channel, including a live side-by-side comparison.
Same AI tools. Same features. One terminal with our framework, one without. The difference will make you rethink how you’re currently building.
The Seductive Trap of AI Coding
Here’s the thing nobody wants to admit. There’s a huge seductive trap when it comes to AI. You can skip the entire planning part. You can go right to building. You try to ship something without enterprise hardening, without making sure your codebase is tight.
You might feel like a genius. All these lines of code and you didn’t really have to do much. The AI just did it for you.
Until you have to change something and have no idea what it actually does.
What we’re seeing is that most people spend 30% of their time actually building something. Then they spend 70% of their time after it’s built just trying to make it work. Troubleshooting. Figuring out what’s wrong. It’s just a mess.
Why? Because there’s no proper spec. No PRD (product requirement document). No shared understanding between you and your AI.
The House Analogy That Changes Everything
It’s like going to a contractor and asking him to build you a house without a blueprint. You never went to an architect. You just said “do whatever.”
Chris put it perfectly in the video. It’s not just that there’s no spec. People skip their system design entirely. They think about a spec that lists features, but nobody thinks about how those features actually connect.
A feature list is like a list of rooms. Your system design is the load-bearing walls, the plumbing, the electrical.
Vibe coders are listing rooms and wondering why the house collapses.
The Deeper Problem: AI is Stateless
Here’s what makes this even worse. AI is stateless. It starts every session as a blank slate. There’s no memory of your architecture design, your business logic, your constraints.
Every single new session starts from zero.
Your job as a human is not just to describe the features. It’s to build the whole context around what you’re giving to AI so it can make good decisions.
At a minimum, that’s what a spec does. But the real unlock is in the persistent context that travels with your project.
The Framework: Seed + PAUL
The real secret is having a proper framework. An orchestration layer. Those things truly matter when building with Claude Code or any agentic coding tool.
Most of us are not senior-level engineers. So how do you understand how an engineer would build without actually being one?
That’s where frameworks like PAUL and Seed come in. Chris built both of these. They’re available on GitHub. And if you’ve seen any of the other videos on Charlie Automates, you know they’re incredibly useful.
What Seed Does
Seed is the step before PAUL. It lets you discuss your application or whatever project you have. During this ideation process, you can explore technologies, break down pros and cons, and really hone in on the best approach.
It follows your workspace structure. So your project gets built according to how your workspace is organized. Every planning document follows a consistent template for the type of plan you’re creating.
The planning documents include:
- Problem statement that defines what you’re solving
- Tech stack with rationale for each choice
- Data models so there’s no guessing
- Security considerations baked in from the start
- Skill loadouts that pull in the right tools for your project (like UI/UX Pro Max for frontend design, or SonarQube for code quality)
And here’s the key part. You get this full document before you’ve ever touched a single line of code.
What PAUL Does
PAUL expects the template types that Seed creates. When you initialize a PAUL project, it uses that planning document to build out:
- The roadmap that tracks state over time
- The state file that tells Claude where your app is right now
- The project specs broken down phase by phase
PAUL is built to pull in the skills that are part of your processes into the relevant projects and plans you’re working with. It does this in a headless way where it doesn’t re-ask anything. From the planning doc, it scaffolds everything with architecture and systems design baked in.
AI Performs Best When Constrained
This is a concept that a lot of vibe coders miss. AI is at its optimal performance whenever it is constrained.
The more constraints you give, the more guardrails you put in place, the more laser-focused it becomes. Chris uses the word “surgical” a lot. And he’s right.
While vibe coders are in the weeds, grabbing screenshots and pasting error logs back and forth, Chris is sitting there just telling Claude “Yes, proceed.” That’s it. That’s the whole workflow once the framework is set up.
Most vibe coders spend their time saying “fix this, debug that.” Chris spends his time saying “looks good, proceed.”
That’s the difference.
The 4-Step Process
Here’s the actual process, broken down:
Step 1: The Spec
Create your planning document using Seed. Discuss with Claude Code in plan mode for about 10 minutes. Think about what you want to build. That’s really all it is. It’s not corporate bureaucracy. It’s just thinking before you build.
This should take you no longer than 10 minutes.
Step 2: Prompt With the Spec as Context
Feed that spec into PAUL. The framework initializes your project with the roadmap, state tracking, and phase-by-phase build plans. No re-asking. No guessing. Just a clean handoff from planning to building.
Step 3: Build and Review Phase by Phase
Each phase has a different portion. Some might be more frontend. Some might be just backend functionality. But you review each phase as it completes.
A huge part of success here is UAT, user acceptance testing. Every time Claude moves forward on a part of the project, you review and make sure it’s doing what you actually want it to do.
Don’t just say yes, yes, yes and end up with garbage. Test before you add, run the app, verify the feature, commit, then move to the next one.
Step 4: Test Before You Add
This is where most people fail. They stack feature on top of feature without verifying anything works. Then they’re buried in bugs they can’t trace.
If the frontend is built, make sure it’s viewable and looks solid. Check every step of the way. Make sure it’s moving in the direction you want it to go.
What “Drift” Is and Why It Kills Your App
Chris and I talk about something called drift. It’s where a decision is made and put in place, and then later something incompatible is done. That incompatibility can be silent. Hidden.
They’re like chaos ninjas in your code that you don’t even know are there.
The state file prevents this. Every decision made, every deferment, everything that’s logged gets tracked. The roadmap tracks the state over time. The state file tells Claude where your app is right here, right now. The roadmap tells it where it’s been the whole way through.
No drift. No invisible walls. No nightmares.
The Five Levels of Claude Code Mastery
Chris broke down five levels of progression:
Level 1: You’re just running with a Claude MD file. Basic setup, basic prompting.
Level 2: You have some skills and a Claude MD file. You’re starting to use tools intentionally.
Level 3: You’ve got hooks firing that automate between your skills. You’re getting the start of what a workflow might look like.
Level 4: Full framework and workflow thinking. Combining all of the above in an executable way. This is PAUL. This is Seed. This is the system we demonstrated in the video.
Level 5: Systems design thinking. The overarching design perspective that you maintain every day as you’re building inside Claude Code. This is why PAUL exists. Each framework added to the tool stack accelerates every future project.
Chris said it best. The time it takes him to build an app today is at least 10 times faster with better code quality than his first app. Because along the way, he took Level 5 thinking with him and built the frameworks based on his experience with Claude.
That is Level 5.
The Side-by-Side Comparison
In the video, Chris ran two terminals simultaneously. On the left, plain Claude Code with no framework and no planning. Just “hey Claude, build this.”
On the right, the Seed + PAUL framework with proper planning and structure.
The left side? Claude was freehanding. No idea where the project was being built. Files in random places. No structure. No guardrails.
The right side? Claude asked the right questions before building anything. It thought about how pieces connect before starting. It followed the workspace structure and generated consistent planning documents.
The left side was already “building” while the right side was still planning. But here’s the thing. The right side shipped a working, well-structured app. The left side hit a wall.
We’ve seen this pattern hundreds of times. And it’s the same wall every time.
It’s the 80/20 Principle
We’re getting 80% of our results from about 20% input. That’s the power of the framework. You invest 10 minutes in planning and save hours of debugging, restructuring, and starting over.
The framework thinks so you don’t have to white-knuckle every line of code. It constrains Claude so it performs at its best. It tracks decisions so nothing drifts silently.
That’s the fix. That’s why 90% of Claude Code apps fail. Not because the AI isn’t good enough. Because the human didn’t give it enough structure to succeed.
Get the Frameworks
Everything we showed in this video is available. Seed and PAUL are on GitHub. We build in public. The same frameworks we use for CC Strategic client work are the same frameworks you get access to.
If you want a deeper breakdown, join CC Strategic AI on Skool. We have free AI tools, templates, and resources around Claude Code from beginner to advanced. You get access to our Claude Code tool belt and there’s never any pressure to upgrade.
If you want personalized help implementing these frameworks for your specific projects, work with me 1-on-1. I’ll help you set up the exact system Chris and I use every day.
And if you need this level of execution for your business, book a call with CC Strategic. We build these systems for clients and ship real products.
FAQ
What is the #1 reason Claude Code apps fail?
Lack of planning and system design. Most people skip straight to building without a spec, a PRD, or any thought about how features connect. They list rooms instead of designing load-bearing walls, plumbing, and electrical. The AI has no persistent context, so every session starts from zero.
What is PAUL and how does it help?
PAUL is a Claude Code framework built by Chris Kahler that manages your entire build process phase by phase. It creates a roadmap, tracks state, and prevents drift by logging every decision. It pulls in the right skills for each project and builds with architecture and systems design baked in.
What is Seed?
Seed is the ideation step that happens before PAUL. It lets you discuss your project, explore technology options, and generate a structured planning document. That document feeds directly into PAUL so Claude has full context from the start.
Do I need to be a developer to use these frameworks?
No. That’s the whole point. Most of us are not senior-level engineers. These frameworks let you think like a system designer without being one. You discuss what you want to build, and the framework handles the architecture and structure.
How long does the planning step take?
About 10 minutes. You discuss with Claude Code in plan mode, think about what you want to build, and let the framework generate your spec. It’s not corporate bureaucracy. It’s just structured thinking.
What is “drift” in AI coding?
Drift is when a decision is made early in a project, and then a later decision is incompatible with it. These incompatibilities are often silent and hidden. The state tracking in PAUL prevents drift by logging every decision and making sure Claude knows the full history of your project.
How much faster is building with frameworks vs. vibe coding?
Chris estimates at least 10x faster with better code quality. Instead of spending 70% of your time debugging after the build, you invest 10 minutes in planning and spend most of your time just saying “yes, proceed.”
Where can I get Seed and PAUL?
Both are available on GitHub. You can also get them through the CC Strategic AI Skool community along with additional resources, templates, and support.
What are the five levels of Claude Code mastery?
Level 1: Claude MD only. Level 2: Skills + Claude MD. Level 3: Hooks automating between skills. Level 4: Full frameworks and workflows (PAUL + Seed). Level 5: Systems design thinking that persists across every project and every day of building.