Master Restraint: Decide What NOT to Build

Speed Without Restraint Bloats Products

AI flips workflows: building now takes 20% of time, planning 80%. But planning shifted from 'how to build' to 'should we build?' Without scarcity, builders ship everything possible, drowning products in features. Enterprise demands on a focused client portal (file sharing/approvals) tempt adding invoicing/time-tracking—each buildable in a weekend. Result: Onboarding swells, support shifts to unrelated issues, original users feel alienated as invoicing seekers dilute focus.

Quote: "Restraint is about choosing focus over capability. The discipline to say, 'We could build this, but it doesn't belong here.'"

Instead, integrate via APIs or agent skills (e.g., pre-built invoicing agent). This serves needs without bloating core identity. Restraint applies equally to internal tools: Avoid monoliths for content ops (news monitoring, drafting, visuals, publishing). Break into purpose-built micro-tools connected by agents—easier to maintain as processes evolve.

Agents excel with focused systems; monoliths brittle under change. Common mistake: Overbuilding from unchecked capability, leading to maintenance hell.

Spec-Driven Development: Plan Mode as Industry Standard

By 2026, tools enforce planning first. Claude Code, Cursor, Codeex (all use Shift-Tab for plan mode) converge on spec-driven workflows. Feed a PRD (overview, problem, target customer, user flow, in/out scope, tech context) into plan mode:

Claude Code: Auto-enters plan mode on PRD paste; asks clarifying questions, generates technical schematics/to-dos. Auto-accept edits to build.
Cursor: Pastes full PRD (no compaction); spawns sub-agents, iterative questions (even on auto-model). Outputs architecture diagrams, data flows, tracked to-dos.
Codeex: Text-based technical plan post-questions; simple 'implement' step.

All track progress autonomously. Nimbleist differentiates: Visual workspace with Markdown mockups, Excalidraw/Mermaid diagrams, data models alongside agent sessions. Tasks auto-update; local Markdown storage (Git-friendly, no lock-in). Spot scope creep visually before coding.

Before/after: Raw PRD → Tool-specific implementation plan (technical breakdown, risks clarified). Quality criteria: Clarifying questions ensure alignment; diagrams reveal gaps.

Quote: "Plan first, then build. Cloud code, cursor, codecs, planning is now a first class feature in all of them... spec-driven development has become the industry standard."

Pitfall: Jumping to plan mode without strategic vetting builds polished junk.

Pre-Planning Framework: Shape Ideas into Scoped PRDs

Before coding tools, run a Claude (or LLM) conversation as strategic partner. Solo: You + AI. Team: Independent runs, then align on convergence/divergence.

Step 1: Brain Dump Raw Idea (Voice Dictation Recommended)

Use tools like MacOS Whisper Flow. Cover:

Feature/tool description.
Primary customer (traction sources; self for internal).
Core problem (job-to-be-done: e.g., "Agencies share deliverables/get approvals without email chaos").
Existing solutions/gaps.
User feedback/quotes/frustrations (use verbatim for authenticity).

Quality check: More customer words = better AI probing.

Step 2: Prompt Claude as Thought Partner

Template:

I'm considering building [description]. Primary customer: [who]. Core problem: [job-to-be-done]. Existing: [gaps]. Feedback: [quotes].

Act as strategic thought partner. Ask clarifying questions on purpose, vision, focus, problem. Be constructive: Challenge assumptions, surface trade-offs, spot scope creep risks. Conversation first—no rushed specs/solutions.

Let LLM generate questions (don't prescribe list—leverages reasoning). Back-and-forth uncovers blind spots.

Quote: "Before I open plan mode in any tool, I run a conversation that determines whether I should be planning this thing at all. So this is the step that most builders and most teams are skipping and it's where restraint actually happens."

Step 3: Direct to PRD Output

After 3-5 rounds, steer to PRD:

Overview: One-paragraph pitch.
Problem: Precise job-to-be-done.
Target Customer: Who fits perfectly (exclude others).
Core User Flow: Step-by-step (diagrams if visual).
In/Out of Scope: Restraint muscle—list exclusions explicitly.
Technical Context: High-level (e.g., stack, integrations).

Example evolution: Client portal raw idea → Clarified (agencies only, no PM/invoicing) → Scoped PRD → Plan mode.

Trade-offs: Time upfront saves rework; critical for solos blurring builder/PM roles. Prerequisites: Basic PM concepts (job-to-be-done); comfortable prompting.

Fits broader workflow: Idea → Pre-plan (restraint) → PRD → Plan mode → Build.

Exercise: Voice-dump next idea; run framework independently if team. Compare PRDs before/after: Bloat reduced?

Key Takeaways

Always ask 'should we?' before 'how?': Use restraint to protect product identity.
Build micro-tools + agent connections over monoliths for ops.
Shift-Tab into plan mode in Claude Code/Cursor/Codeex after PRD.
Brain-dump with customer quotes; prompt LLM to challenge assumptions/scope creep.
Output scoped PRD: Explicit in/out scope prevents feature bloat.
Visual tools like Nimbleist catch issues early via diagrams.
Run pre-planning solo/team; align on divergences for strategy.
Voice dictation accelerates dumps; verbatim feedback grounds prompts.
Practice: Shape one raw idea to PRD this week—feed to tool, build only if passes restraint.