I Migrated from Cursor to Claude Code — and My Output Leveled Up

• One year ago, a medium-complexity feature took me a week.
• With Cursor, I dropped to 1–2 days.
• Today, with Claude Code, I finish large features in a single session (2–3h). The breakthrough came when I lost my fear and started working with real AI agents.

Thesis: when an agent edits dozens of files in seconds, without forgetting imports or losing context, the game changes. The challenge is no longer "writing code," but orchestrating context, tests, and intent.

---

✨ What You'll Find Here

• Pair programming with AI: how I use Claude Code to uncover unknowns, structure thinking, and produce PRDs before implementing.
• 5 proven workflows: explore/plan/code; TDD with agents; visual iteration; safe YOLO mode; Q&A for onboarding.
• “Leaf nodes” in action: how I isolate scope in the [[frontend]] and [[backend]] to make the agent’s job easier and reduce risk.

---

What is Claude Code?

• Anthropic's command-line tool — a pure code agent.
• Unlike IDE extensions (e.g., [[VS Code]]/Cursor), it runs in the terminal and can edit multiple files simultaneously.
• Mental model: In Cursor (even Agent Mode), you tend to supervise every change; with Claude Code, you define objectives and the agent works — like an extremely capable junior, but at AI speed.

Useful definition: Code agents are wrappers on top of LLMs that combine tools + a plan/execute/validate loop (see Anthropic docs).

---

Why I (Partially) Left Cursor

• My transition started in June 2025: I tried Claude Code out of curiosity.
• In July, I risked large features. The first week was tense — giving up control is not trivial.
• Turning point: [[TDD]] with an agent works. I define tests, ensure they fail, then let the agent implement until they pass. Safety net → confidence without reviewing every line.

How I use it today:

• Cursor for: quick reviews, small tweaks, when I want immediate visual feedback, or I'm working solo.
• Claude Code for: large features, refactoring, and teams (the CLAUDE.md is shareable).

Note: I work a lot with [[TypeScript]] and [[Python]]. I found TypeScript easier for the agent: explicit types help define/validate behavior.

---

Real Example

• I needed to identify viewed/applied/uninterested jobs in the UI.
• Without AI: 1–2 weeks. With Cursor: 1–2 days. With Claude Code: ~3 hours (one-shot from a PRD + tests).
• The agent: read the codebase, mapped edge cases, asked about things I hadn’t considered, proposed interfaces, and compiled a plan.
• After, tests ran (written by the agent) and validated business rules; I manually did fine UI/UX tweaks (LLMs still don’t nail pixel-perfect without supervision).

---

My Pair Programming Process with AI

• I open a session and dump context: business problem, current architecture, constraints, technical debt, dependencies.
• I ask it to map unknowns and edge cases. I interrupt with Esc when needed, question decisions, and ask for alternatives.
• Before the context bloats, I require a PRD (Product Requirements Document) with: problem, decisions, edge cases, and acceptance criteria. This PRD becomes input for a new agent session focused on implementation.

Goal: you won’t review everything. So code for verifiability (tests, asserts, type contracts, e2e, snapshots).

---

Minimal Setup: CLAUDE.md + Useful Commands

Key Commands

• claude — normal session
• claude --dangerously-skip-permissions — YOLO for mechanical tasks (formatting, lint, boilerplate)
• Esc — interrupts; double Esc — goes back in history and edits the previous prompt
• /clear — clears a long context
• /compact — summarizes and keeps the essentials

CLAUDE.md (project persistent memory)

• Add conventions, scripts, style, limits.
• Use comments with # to set rules the agent cannot violate (e.g.: "never edit /dist", "run tests with npm run test", naming, mypy strict, etc.).
• Write prompts in English when maximum precision is required.

---

5 Workflows That Really Work

1) Explore → Plan → Code → Commit

• Forbid code during exploration: “don’t write code yet”.
• Use think levels (“think / think hard / ultrathink”) to force analysis before doing.
• Generate issue/PRD as a checkpoint.

2) TDD with Agents

• First the tests, ensure they fail, commit.
• Then, ask for the implementation until they pass (without changing the tests).

3) Visual Iteration (with [[Playwright]] [[MCP]])

• For [[frontend]]: the agent implements, takes screenshots, compares, and iterates until matching the mock.

4) Safe YOLO

• Use YOLO flag only for mechanical tasks and always in an isolated branch.

5) Q&A for Onboarding

• Ask the agent the same questions you’d ask a new team dev: logs, feature flags, historical decisions, trade-offs.

---

“Leaf Nodes”: How I Reduce Context and Risk

• [[Frontend]]: break large components into cohesive subcomponents (<DashboardLayout>, <ChartSection>, <FilterBar>).
• [[Backend]]: modularize (users.ts, auth.ts, payments.ts).
• The agent works where nothing critical directly depends → less chance of collateral damage.

---

Context Engineering: The Art of Packaging the Context Window

• Useful definition: designing what goes into context, how it goes in, and when.
• Alongside CLAUDE.md, include key files for the feature and validation contracts (tests/fixtures/schemas).
• Recommended read: [[Igor Cleto]] — “AI Agents 101: What is Context Engineering?”.

---

Observed Versatility

• Complex debugging (the agent navigates stack traces),
• Pixel-perfect CSS tweaks (with visual verification),
• Exploring unknown codebases (git blame + history).
• The result: a single development environment that covers from PRD to merge.

---

Tips to Speed Up Your Learning Curve

• Be specific early: vague prompts → bad code.
• Invest in fast dev: slow tests kill the feedback loop.
• Set up CLAUDE.md on day one.
• TDD is your safety net.
• Few [[MCP]]s: each plugin pollutes the context; keep only those that add value (I mainly use [[Playwright]]).

---

Next Steps (Practical Roadmap)

1. Try the free tier of Claude Code.
2. Start on a personal project (nothing critical).
3. Implement basic TDD on your stack.
4. Create your CLAUDE.md with your team’s real conventions.
5. Pick 1–2 “leaf nodes” and run a one-shot guided by a PRD.

---

Honest Summary

• Claude Code ≠ “smart extension” — it's a command-line agent that edits multiple files and orchestrates tasks.
• 10x productivity comes from process + context + tests, not from “magic prompts.”
• Limitations exist (fine UI, product decisions), but the net gain is huge: I now deliver in hours what used to take weeks.