How I Start EVERY Claude Code Project

Overview

The video explains a repeatable way to start every Claude Code project using a simple PSB workflow:

1. Plan (make a project spec)
2. Setup (configure Claude Code with a checklist)
3. Build (use consistent development workflows to ship an MVP and milestones faster)

The core claim is that this reduces messy early prompting and saves significant time by giving Claude clearer requirements, context, and automation.

---

Phase 1: Plan (PSB “Plan”)

Key idea: don’t start coding with freestyle prompts

The speaker previously began by directly prompting in the terminal with no structure, which led to inefficient, error-prone projects. They developed a planning system instead.

Two critical planning questions

1. Goal: What are you actually trying to do?

   • Examples: learn tech, validate an idea with customers, prototype, build an alpha, etc.
   • The goal determines how “production-ready” the output must be (prototype vs ship-ready).

2. Milestones: What functionality milestones define success?

   • Common approach: MVP first, then 1–2 improvement versions.

Using AI to plan

• Pro tip: have Claude ask you questions to clarify your brainstorm.
• Input is a markdown brainstorm file; then ask Claude:
  • what questions must be answered to build a successful MVP
• Also mentions using a voice-mode conversation to talk through features/user flows, then asking AI to summarize into markdown.

Deliverable: “Project Spec Doc”

The project spec doc is positioned as the main “contract” Claude Code uses to build. It has two parts:

1) Product requirements

Answers:

• Who it’s for
• What problems it solves
• What the product should do

Emphasis:

• Be specific about user interactions/workflows so Claude won’t guess.
• Don’t try to build everything at once—use capability milestones.
• If unsure, build version one, then iterate product requirements.

2) Engineering requirements (engineering design doc)

Includes:

• Tech stack choices (explicitly recommended to prevent Claude from picking random tools)
• Technical architecture
  • system design overview
  • component interactions
  • database schema
  • API design
  • infra provisioning steps (create DB, set up hosting, generate API keys early)

Web search capability in Claude Code is highlighted as a way to generate a research report with options/recommendations when you don’t know the stack.

---

Phase 2: Setup (PSB “Setup”)

The video provides a 7-step setup checklist to tune Claude Code for efficient builds. Not all steps must be used—pick what fits.

Step 1: Set up a GitHub repo

Why:

• Enables Claude Code on web/mobile
• Access to GitHub CLI and Claude Code GitHub action (useful for PRs and automated PR review)
• Allows deploy providers (example: Vercel) to deploy via repo connections and support deploy previews
• Supports issue-based development and parallel work

Step 2: Create an environment variable file

• Ask Claude to generate an example env file from the spec/stack
• Copy it and fill in real credentials so Claude doesn’t stall asking for secrets

Step 3: Create claude.md (project memory)

Key practices:

• Keep it finite (avoid bloating)
• Include essentials:
  • project goals + architecture overview
  • design/style + UX guidelines
  • constraints/policies (e.g., don’t push to main directly; use env vars for secrets)
  • repo etiquette (PR rules, branch naming, command shortcuts)
  • testing/build instructions
• Best practice: link out to other docs (architecture.md, spec doc, etc.) instead of duplicating content.

Step 4: Automated documentation (docs separate from claude.md)

Core docs suggested (4):

1. architecture.md
2. change_log.md
3. project_status.md (milestones, what’s done, where you left off)
4. feature reference docs for key areas (optional; helps when searching code isn’t enough)

Automation approach:

• Tell Claude to update docs as it works (instruction in claude.md or via a custom command).

Step 5: Plugins

Plugins extend Claude Code with:

• slash commands
• sub agents
• MCP servers
• hooks/skills
• install/management via /plugins

Recommended plugin examples:

• Anthropic front-end plugin (UI-focused)
• Anthropic feature dev plugin (streamlined feature development)
• “Every compound…injuring” plugin (adds commands/sub-agents aimed at making features easier over time)

Step 6: MCPs (Model Context Protocol servers)

MCPs integrate Claude Code with tools/services so Claude can:

• interact with databases
• test front-end
• deploy
• do other tasks that otherwise aren’t possible

Examples mentioned:

• Database MCPs (MongoDB, Supabase)
• Browser/testing MCPs (Playwright, Puppeteer) for web apps
• Deploy MCP (Vercel)
• Analytics MCP (Mixpanel)
• PM MCP (Linear)

Recommendation:

• Set up only the MCPs that match your stack and accelerate your iteration.

Step 7: Slash commands and sub agents

Distinction:

• Slash commands = shortcut prompts/tasks in the same context window
• Sub agents = specialized agents using a separate/forked context, not aware of other sub agents (good for parallelism)

Built-in sub agents highlighted:

• planning sub agent
• codebase search sub agent

Suggested custom sub agents:

• change log sub agent
• front-end testing sub agent (runs Playwright tests)
• retro agent (reflects on improvements and updates docs/prompts/commands)

Example custom slash commands:

• update project docs from automated documentation
• generate GitHub issues from a spec/prompt

Bonus advanced setup tips

1. Preconfigure permissions/settings
   • prevent Claude from being blocked waiting for approvals
2. Hooks for automation
   • scripts triggered at lifecycle moments (e.g., after a task finishes)
   • examples: rerun/fix tests; notify on Slack when permission is needed

---

Phase 3: Build (PSB “Build”)

The build phase uses the planning + setup outputs (spec + milestones + Claude configuration).

MVP-first

• Have Claude implement milestone one based on the project spec.
• Pro tip: use parallel sub agents where possible during implementation.
• Use plan mode so Claude translates the spec into an internal implementation plan with clarifying questions.

---

Three development workflows

Workflow 1: General workflow (end-to-end single feature)

Four steps:

1. Research (optional; can use Claude research report or external ChatGPT Deep Research)
2. Plan (emphasized as the biggest mistake area—people don’t use plan mode enough)
3. Implement (uses configured plugins/sub-agents/MCPs)
4. Test

Workflow 2: Issue-based development (GitHub issues as truth)

• Create GitHub issues for bugs/improvements/features.
• Claude works on an issue rather than from ad-hoc to-dos.
• Discipline: split work into issues.
• Automation is possible via slash command/sub agent to convert spec → GitHub issues.
• Benefit: easier parallel work (multiple issues via sub agents or multiple Claude Code instances).

Workflow 3: Multi-agent development (“multi-clouding”)

• Run multiple Claude Code instances simultaneously, each working on different features.
• Coordination concern: merge conflicts.
• Solution: use Git worktrees to isolate working copies per branch/workspace while sharing repo history.
• After completion, merge worktrees into main or feature branches for testing/review.

---

Productivity tips during build

1. Use best models as much as possible

   • Suggested pattern: Opus for planning/complex tasks, Sonnet as implementation workhorse, Haiku only for simple tasks/bug fixes.
   • Rationale: fewer mistakes reduce total fix/rework time.

2. Periodically update and tune claude.md

   • Can create a command to update claude.md then commit it.

3. Regression prevention via “hashtag/pound”

   • When Claude makes a mistake, type # to instruct Claude to incorporate learnings into claude.md immediately (via a “relevant” section).

4. Don’t be afraid to throw away work

   • Use Claude Code checkpoints/rewind for recovery; rely on Git for project-level version control.

---

Product / tech examples (stack suggestion)

A suggested web-app stack includes:

• Front-end/hosting: Vercel, Next.js, Tailwind, shadcn
• Back-end/database: MongoDB or Supabase
• Auth: Clerk
• Payments: Stripe
• Email: Resend
• Hosting (if needed): DigitalOcean
• Storage: Cloudflare R2
• AI: Anthropic models; images via Gemini (“Nano Banana”)

Note: it’s presented as a suggestion—specify what you want Claude to use.

---

Main speakers / sources

• Main speaker/source: The video creator, teaching “best AI coding tools” and sharing their Claude Code workflow throughout (no specific name given in the subtitles).
• Primary tool discussed: Claude Code (Anthropic ecosystem) and related integrations (GitHub, Vercel, MCP servers, plugins like Anthropic plugins).