I Asked Claude Code to Make Me as Much Money as Possible

TL;DR

Claude is tuned to make you feel productive, not to make you money — and your income is capped by output quality × speed. Nate fixes four baked-in problems with four upgrades, building a real business live to demo each: (1) Roast — a council-of-personas skill that stress-tests your idea instead of agreeing with you; (2) Verify — a methodology that makes Claude check and stress-test its own work before saying "done"; (3) Context management — treat the window like a desk (a session-handoff skill + /clear beats /compact); (4) Sub-agents + /goal — parallel agents each with a clean context, driven to a completion condition graded by a separate judge model. The meta-shift: you stop being the builder and become the decision-maker, reviewer, and judge.

Key takeaways

• Feeling productive ≠ making money. Income = quality × speed of output; every default that lowers either costs you.
• Sycophancy is measured, not vibes. The "ELEPHANT" study: models fail to push back ~88% of the time (humans ~60%), and memory/personalization makes them more agreeable over time — so build in a devil's advocate.
• "Roast" skill: a council — contrarian, expansionist, first-principles, deep researcher, and a role-played buyer — plus a judge that returns green-light / reshape / kill and the single cheapest 48-hour test.
• "Finished" ≠ "working." (An NYU study found ~40% of Copilot programs had security holes.) Make Claude verify (screenshot + click through with Playwright, to a written definition of done) then stress-test for edge cases.
• Context rot is real: every model degrades as the conversation grows, well before the window fills — "more is not better." Use /context to see what's eating it, and a session-handoff skill (summarize state → /clear → paste) to start clean without losing the thread.
• You are the bottleneck. Anthropic's own test: a lead agent + parallel sub-agents beat a single agent by >90%. Sub-agents each get a clean context (no context rot), and /goal runs turn-after-turn until a separate evaluator model grades it done — separating the worker from the judge.
• The role shift: from builder/producer → problem-solver, decision-maker, reviewer, judge.

---

Upgrade 1 · Roast — stop it agreeing with you

Claude wants you to like it, so it rubber-stamps ideas. The roast skill pulls it out of agreement mode by spinning up a council that attacks the idea from different angles, then a judge issues a verdict:

flowchart TD
    IDEA["Your idea"] --> C["🔴 Contrarian — find fatal flaws"]
    IDEA --> E["🟢 Expansionist — biggest upside"]
    IDEA --> F["⚪ First-principles — pure logic"]
    IDEA --> R["🔵 Deep researcher — real market/competitor data"]
    IDEA --> B["🟣 Buyer — role-plays your customer: buy or not?"]
    C & E & F & R & B --> J["⚖️ Judge"]
    J --> V["Verdict: green-light / reshape / kill<br/>+ cheapest 48-hour test"]

The value isn't the exact skill — it's the methodology: always default to stress-testing ideas from multiple perspectives before building.

Upgrade 2 · Verify — make it check its own work

Claude hands you something that looks finished. Make it prove the work, like a factory testing each part and then the whole car:

flowchart LR
    BUILD["Build it"] --> VER["Verify: start server → Playwright<br/>screenshot each section, both viewports"]
    VER -->|"errors?"| BUILD
    VER --> STRESS["Stress-test: headed browser,<br/>submit forms, hunt edge cases"]
    STRESS --> DOD{"Definition of done met?<br/>(zero errors)"}
    DOD -->|"no"| BUILD
    DOD -->|"yes"| SHIP["✅ Reviewable, actually works"]

Demo: a live landing page + waitlist, verified with 11 screenshots per viewport and 22 form-submission tests (8 valid, 14 malformed) — surfacing bugs (spaces before an email) and honest gaps (no duplicate guard) a human would miss. One-shot gets you ~65%; verification gets you ~90% before you even touch it.

Upgrade 3 · Manage your context

Think of the context window as a desk: pile on paper and it's harder to find the one document. So watch it and reset deliberately — /context to see what's consuming it, /clear to wipe, and a session-handoff skill (summary of state, key files, open decisions, where to resume) instead of the slow /compact. He starts a fresh session once context passes ~250k of a 1M window, and can even hand off to a different model or Codex.

Upgrade 4 · Sub-agents + /goal — stop being the bottleneck

You can only point Claude one direction at a time. Fan out with parallel sub-agents (each a separate Claude with its own clean context) and drive the whole thing with /goal — a completion condition checked every turn by a separate evaluator model, so Claude can't declare itself done:

flowchart TD
    GOAL["/goal — objective completion condition<br/>(e.g. all 6 files exist, non-empty, ≥7 competitors)"] --> LEAD["Lead agent"]
    LEAD --> S1["🤖 sub-agent · positioning"]
    LEAD --> S2["🤖 sub-agent · market research"]
    LEAD --> S3["🤖 sub-agent · launch plan"]
    LEAD --> S4["🤖 sub-agent · outreach + drafts + calendar"]
    S1 & S2 & S3 & S4 -->|"each own context"| MERGE["Verification pass"]
    MERGE --> EVAL{"Separate evaluator:<br/>done = true?"}
    EVAL -->|"no"| LEAD
    EVAL -->|"yes"| DONE["✅ Full go-to-market kit"]

This last move stacks all four upgrades: the idea was roasted, the work self-verifies, each sub-agent dodges context rot, and /goal drives it home. Result: a complete go-to-market kit (positioning, market research, launch plan, outreach, content calendar) in ~8 minutes.

---

The real point

Wire these together and your job changes: stop letting it agree (build the right thing), make it check its work (ship things that work), manage context (stay sharp), and use sub-agents + /goal (work without you). You move from builder and producer to decision-maker, reviewer, and judge — which is exactly the leverage that turns an AI coding tool into a business partner.