Video summary

Plan Mode in Claude Code | Ultraplan Mode in Claude Code | CampusX

Main summary

Key takeaways

Technology

Tech concepts & workflow covered

Context from previous videos (recap)

  • Context window
  • clot.md
  • Spec-Driven Development (SDD) as a core workflow

Project goal introduced

Build an Expense Tracker web app where users can:

  • Create accounts
  • Log in
  • Record expenses
  • Analyze them

Today’s focus:

  1. Setting up the database
  2. Learning Plan Mode

Database setup implemented via Spec-Driven Development

Feature being built (database setup)

  • Create required DB tables
  • Insert dummy/sample data
  • Implement reusable database helper functions in a db.py-style file

Spec creation & structure

Uses a Spec Document defining:

  • Database schema
  • Acceptance criteria
  • Expected behavior

Schema details

  • users table with columns: ID, Name, Email, Password Hash, Created At
  • expenses table storing expense details per user (e.g., amount, category, date, description, created at), including types/constraints as specified in the spec

Notes / constraints

  • No ORM usage (explicitly: “don’t use ORMs”)
  • Use parameterized queries only
  • Specific date format requirement
  • Required error handling
  • Acceptance criteria used to verify completion

db.py functions planned/implemented

  • GetDB: open and return a database connection
  • init_tb: initialize tables by creating them only if not already created
  • cdb: seed the DB with dummy data

Integration into the app

  • app.py updated to import and use the three functions from the database module

Folder location for specs

  • Specs saved under: .clots/specs/
  • Example file name: Database setup.md

Plan Mode: how it works and what was done

What Plan Mode is

When triggered, Claude Code runs planning with multiple agents.

  • Read-only during planning: it cannot write files
  • After plan creation, you grant permission for Claude Code to implement the plan

How Plan Mode is invoked

  • Shift+Tab twice (UI-based), or
  • Command: /plan

Plan output is saved to a Plans folder (intended during the run).

Real issue encountered

  • The first plan attempt failed due to Claude Code temporarily being down / an API error
  • The plan was retried after confirming services were back up

Manual approval implementation

Implementation was run with “Manually Approved Edits”. Claude Code applied changes to:

  • db.py (tables + query functions)
  • app.py (imports and integration)

Validation performed

  • Confirmed the generated database file existed
  • Verified:
    • users includes the created demo user
    • expenses includes inserted dummy expenses across multiple categories
  • Re-run safety: no duplicate seed data on repeated runs (per expectation)
  • Ran the app to ensure:
    • the app starts without errors
    • parameterized query behavior exists (mentions parameterized “sequel” queries)
  • Confirmed:
    • db.py contains the expected three functions
    • parameterized SQL usage is present

Post-implementation engineering actions

Git workflow:

  1. Create feature branch
  2. Commit
  3. Push
  4. Create Pull Request
  5. Merge to main
  6. Update local main via pull
  7. Delete feature branch

Additional Plan Mode “best practices” (settings)

Model choice for planning

Claude Code models include HQO, Sonet, and Opus (Opus is described as most powerful).

Recommendation:

  • Use Opus for complex multi-file planning
  • Downside: Opus consumes more tokens during plan mode

Switch using: /model

Extended Thinking

Recommended to enable before/while planning.

Mechanism:

  • The model reasons first in a scratch pad, then answers.

Enable/disable via:

  • /config
  • “thinking mode”

Tradeoff:

  • More tokens (more costly)

Effort level

Controls how many tokens the model can spend on scratchpad reasoning. Options:

  • Low / Medium / High / Max / Auto

Recommendation:

  • Medium to High (balanced quality vs token cost)

Toggle via: /effort

Ultra Plan (alternative to Plan Mode)

When to use

For very complex planning where normal Plan Mode output isn’t sufficient.

How it differs

  • Planning runs in the cloud using a container (described as Opus 4.6)
  • Claude Code develops the plan remotely with a richer experience, then returns the results

Invocation

  • /ultra plan
  • Provides an option to monitor progress via a web link

Example shown

  • Re-planning the already-implemented database setup:
    • Ultra Plan detected it matches the spec and indicated no changes needed
  • Second example: planning a registration feature without a spec document (then canceled in the demo)

Cost caution

  • More expensive / more tokens than Plan Mode
  • Consider it overkill unless needed

Main speakers / sources

  • Nitish (speaker/creator, “My name is Nitish”)
  • Claude Code / Anthropic (tooling described: Plan Mode, Ultra Plan, models, config settings)

Original video