I am a solo founder building a decision integrity AI app that helps founders in every step of their dealmaking process. It protects them from bad deals and bad people. I’m building my product with the help of AI and Bubble.io.
Claude of Anthropic is my CTO, lead engineer, and my writing polisher. She is my key player for this venture. Through Claude’s Cowork system, she is able to work inside my computer and online software with me. I recently upgraded my Anthropic plan from $20 a month to $200 a month because of the heavy lifting marathon sessions needed to build my product.
Nova, my ChatGPT from OpenAI, is my COO and lead researcher and writer. Through Codex, she is also able to work inside my computer and online software with me. My OpenAI plan costs $20 a month.
Gem is Gemini, a Google product. She is my everyday researcher under its free plan.
Between Friday, July 17 to Saturday, July 18, 2026, I used up all of my Anthropic weekly allotment of credits after undergoing 16.5 hours of vibe coding, technical work, and strategy on Claude Cowork powered by Opus 4.8. This past week I burned hundreds of dollars of Anthropic’s pay-as-you-go usage credits after I used up my weekly allotment of credits for my $200 a month Max Plan that has 20x more usage than its Pro plan that costs about $20 month.
I continued my work on Sunday, July 25, 2026. This time I tested out Anthropic’s Fable 5. It was extremely fast in execution, but it burned though about $200 within 90 minutes. For the rest of that Sunday until Friday, July 24, 2026, I spent another $700 of Anthropic’s pay-as-you-go usage to keep building my AI app. This is very costly for me. Consequently, I decided to change my Anthropic AI use strategy.
After confiding with Nova, I am now testing my Anthropic division of labor strategy using Claude Cowork and its different models below:
Sonnet: my everyday Bubble builder. Think of Sonnet as my Bubble implementation engineer.
Use Sonnet 5 for roughly 70–80% of my work.
Best for:
- Creating and modifying Bubble fields, data types, pages and reusable elements
- Building ordinary frontend and backend workflows
- Responsive-layout instructions
- Conditional visibility and navigation
- Repeating groups, searches and filters
- Drafting API Connector configurations
- Writing interface copy and onboarding text
- Explaining Bubble actions step by step
- Making small, clearly bounded feature changes
- Documenting what I built
- Running routine test cases
Sonnet 5 is the best default because it offers strong coding, reasoning and tool-use performance at substantially lower cost than Opus or Fable. Anthropic says higher-effort Sonnet can match Opus-class performance on some tasks.
Opus: my senior engineer and quality-control reviewer. Think of Opus as my senior Bubble engineer, debugger and QA lead.
Use Opus for approximately 15–25% of the work, particularly when the change is complex, consequential or difficult to diagnose.
Best for:
- Debugging workflows that Sonnet cannot fix
- Reviewing Sonnet’s proposed Bubble implementation
- Designing backend workflows and recursive processes
- Finding race conditions, duplicated actions or inconsistent database states
- API authentication and complicated JSON structures
- Privacy-rule design
- Performance optimization
- Complex search constraints and database relationships
- Decision-scoring logic
- Prompt engineering for the AI analysis layer
- Determining whether a problem is caused by Bubble, the API, the database or the prompt
- Creating test plans for consequential features
Opus is especially valuable for my AI app because my product is not merely a user-interface application. Its credibility will depend on reasoning quality, data integrity, explainability, privacy, and consistent workflow behavior. Anthropic positions Opus for complex systems engineering, multistep reasoning and agentic work, with greater reliability and willingness to flag uncertainty.
Fable: my CTO and architecture escalation model. Think of Fable as my CTO, systems architect, and final escalation point.
Use Fable selectively—perhaps 5–10% of my work.
Fable should not become my everyday model merely because it is the most capable. Use it when the problem is large enough that solving it incorrectly could waste days or force me to rebuild major portions of the application.
Best for:
- Designing or redesigning the entire AI app architecture
- Planning a major product version
- Mapping dependencies across many Bubble pages, workflows and data types
- Designing the Decision Integrity Engine
- Conducting an application-wide technical audit
- Root-cause investigations where the source of the problem is unclear
- Planning a complicated migration of existing Bubble data
- Resolving architectural dead ends
- Creating a comprehensive implementation plan from product requirements
- Reviewing the combined work of Sonnet and Opus
- Determining what should be built, deferred, removed or rebuilt
Fable is explicitly designed for ambiguous, long-running tasks, major investigations and work larger than a single sitting. Anthropic recommends giving it the desired outcome rather than micromanaging every step.
My recommended workflow
1. Start major features with Fable or Opus
Before touching Bubble, ask Fable to architect only the most important or cross-cutting features. Use Opus for complex but more contained features.
The deliverable should include:
- Objective
- User story
- Data-model changes
- Pages and reusable elements affected
- Frontend workflows
- Backend workflows
- Privacy implications
- Failure states
- Test cases
- Rollback plan
2. Give the approved plan to Sonnet
Have Sonnet convert that architecture into small Bubble tasks:
“Implement only Phase 1. Give me one Bubble action at a time. Use Bubble’s exact terminology. Stop after each logical milestone so I can confirm what appears in the editor.”
This reduces the risk of long, vague instructions that cause Bubble prompt loops.
3. Return to Opus for review
After implementation, give Opus screenshots, workflow descriptions and test results:
“Review what was actually implemented against the approved specification. Identify omissions, security issues, inconsistent states and edge cases.”
4. Escalate to Fable only when necessary
Use Fable when:
- Opus cannot establish the root cause.
- A change affects several major subsystems.
- I suspect the current architecture is wrong.
- I am preparing for a major release.
- I need an application-wide audit rather than another patch.
Anthropic specifically describes an “advisor” pattern in which Fable or Opus sets strategy while Sonnet performs the less expensive execution work.
Bottom line
My optimal setup is:
Fable decides the architecture.
Opus challenges, debugs and validates it.
Sonnet performs the daily Bubble construction.
Do not have Fable build every button. Do not expect Sonnet to independently make every consequential architectural decision. Use Opus as the bridge between strategy and implementation.
I’m so excited to test this strategy out.
With Warmest Aloha, Jon Riki Karamatsu
