Why Not Just Use ChatGPT?
Most AI coding tools work without context, without memory, without quality control. Claude Code is fundamentally different.
ChatGPT / Gemini / Copilot Chat
- No access to filesystem or project
- Context lost after every session
- Generic answers without project knowledge
- Copy-paste between browser and IDE
- One model for everything — no specialization
- No automatic quality checks
- No access to database, CI/CD, docs
Claude Code (Agentic Coding)
- Direct filesystem access: read, write, edit
- Persistent memory across sessions
- Knows the entire project including architecture
- Works directly in terminal — no copy-paste
- Specialized agents for different tasks
- Automatic build, lint, and security checks
- Tool integration: DB, Confluence, browser, email
The secret: It's not the AI alone that makes the difference — it's the structure around it. A well-designed system of context, specialization, and verification turns a language model into a real development partner.
Three Layers, One System
The setup is organized in three layers: global standards, project-specific context, and runtime tools.
The global configuration applies to all projects. It defines coding standards, language rules, team structure, preferred technologies, and the agent workflow.
Key principle: The global CLAUDE.md is the "constitution" — it contains rules that Claude loads automatically at every conversation start. Naming conventions, tech stack preferences, accessibility standards, git workflow: defined once, applied consistently.
Each project has its own lean CLAUDE.md and a /dev folder with detailed documentation.
Session start: Claude automatically reads CLAUDE.md and instantly knows: which app, which DB schema, which edge functions, which coding patterns. No context ramp-up — every session starts with full knowledge.
At runtime, Claude Code connects to external services via Model Context Protocol (MCP) and uses an arsenal of specialized skills and sub-agents.
MCP Servers
Supabase (DB, migrations), Atlassian (Confluence/Jira), Playwright (browser), Sequential Thinking, Google Suite
Filesystem
Read, Edit, Write, Glob, Grep, Bash terminal — direct access to all project files without intermediary
Sub-Agents
Parallel specialists: Explore (codebase search), Plan (architecture), /devteam agents (pipeline)
MCP Servers — Claude Talks to the World
The Model Context Protocol connects Claude Code to external services. Not chatting about code — but taking direct action.
Supabase
Direct SQL queries, deploy migrations, manage edge functions, read logs, verify RLS policies — all without the Supabase Dashboard.
Atlassian
Read and update Confluence pages, create Jira issues, keep product documentation in sync — bidirectionally.
Playwright
Remote-control browsers: navigate pages, take screenshots, test forms, verify accessibility, detect visual regressions.
Sequential Thinking
Think through complex problems step by step: schema design, architecture decisions, migration plans — structured and deliberate.
Google Suite
Read Gmail and create drafts, manage Google Drive files, calendar events — integrated into the workflow.
Context7
Fetch live documentation for libraries and APIs — current docs instead of outdated training data. Proactively used for every new library.
The difference: Instead of "write me a SQL query that I'll paste into the dashboard," Claude executes the query directly, sees the result, and adapts the code accordingly. Instead of "describe how the page looks," Claude takes a screenshot and verifies it.
Agent-Driven Development
My custom-built workflow: 5 specialized agents with clear roles, strict boundaries, and a human at every gate.
✗ Never creates feature specs
✗ No architecture decisions
✗ No migration without approval
✗ Max 5-7 files per commit
✗ No GO with critical bugs
Core pattern: Negative Constraints. Every agent has explicit NEVER rules. The Planner can't write code. The Developer can't change the schema. The QA can't fix bugs. This prevents scope creep and enforces clean handoffs.
The Feature Spec: Single Source of Truth
Every task is documented as a feature spec. It grows through the pipeline — each agent adds their part.
How a Feature Is Built
From idea to verified implementation — every step with clear responsibility.
Create Business Case
Assessment Manager researches: Is it feasible? Legal hurdles? Worth the investment? Result: GO / NO-GO / CONDITIONAL GO with clear reasoning.
Define Feature Spec
Planner breaks the requirement into testable units. Acceptance criteria, dependencies, edge cases, rollback plan — all documented before a single line of code is written.
Tech Design & Schema
Architect designs DB schema, RLS policies, API endpoints. Creates mockups or architecture diagrams. Security analysis included. Migration SQL is written and reviewed.
Implementation in Batches
Developer implements strictly according to spec. Small commits (max 5-7 files). Build must be green after every batch. Existing patterns are followed, no independent architecture decisions.
QA & Release Gate
Quality Engineer tests against all acceptance criteria. Bugs are documented with severity and handed back — never fixed by QA. Only after a green suite: GO for deployment.
Documentation as Code
7 mandatory files per project. Each with a clear purpose. Together they form the project's memory.
Impact Checklist in detail: Before any change, the checklist verifies 18 areas: DB schema, exports (11 categories!), imports, test data, edge functions, i18n, realtime subscriptions, admin components, storage buckets, WCAG compliance, native app behavior. A forgotten side effect simply can't happen.
Auto-Memory: Remembering Across Sessions
Claude stores learnings in a file-based memory system. Four types: user (preferences), feedback (corrections), project (context), reference (external resources).
38 Test Types Across 18 Categories
A global testing strategy that applies to all projects. Documented on Confluence and as Markdown — always in sync.
Verification strategy: Each test type has a clear schema: What is tested, When (trigger), What it checks (checklist), which Tools are used. The testing strategy lives as a Markdown file and is automatically synchronized with Confluence.
Verification Levels
Automated
Build check after every commit. Lint & TypeCheck. Playwright E2E tests. axe-core for WCAG. CI/CD pipeline on GitHub Actions.
Agent-Based
Quality Engineer checks code against spec. /design-review takes screenshots and verifies UI. /security-review analyzes vulnerabilities.
Manual
UAT on real devices (mobile + desktop). Human gate at every pipeline transition. Final approval before deployment.
Specialized Capabilities
Skills are predefined workflows that extend Claude Code with domain-specific capabilities. Invoked via slash commands.
Custom skills: Using /skill-creator, domain-specific skills can be defined. /devteam is a custom-built skill that orchestrates the entire 5-agent pipeline — including human gates, feature spec management, and handoff logic.
What Happens in a Session
A typical feature — from requirement to deployment. Not hypothetical, but real metrics from production.
Why It Works
Six principles that turn a language model into a real development partner.
Context Over Copy-Paste
Claude knows the entire project: schema, architecture, patterns, history. Not "here's my code, what's wrong?" but "feature X doesn't work" — and Claude knows where to look.
Specialization Over Generalism
5 agents with clear roles and strict boundaries. The Planner plans, the Architect designs, the Developer codes, the QA tests. No agent does everything.
Memory Over Amnesia
Persistent memory system across sessions. Preferences, corrections, project context, and external references — learned once, available forever.
Quality Gates Over Blind Trust
Human gate at every pipeline transition. Impact checklist before every change. 38 test types in QA. Build check after every commit. No change without verification.
Tool Integration Over Isolation
Directly interact with database, Confluence, browser, email. No intermediary steps, no copy-paste. Claude acts — not just advises.
Documentation as Code
7 mandatory files per project. Every change updates the relevant docs. CHANGELOG tracks working hours. PRODUCT-SUMMARY syncs with Confluence. Nothing is lost.
Vibe Coding with Claude Code is not "chatting with AI and hoping for good code." It's a structured system of context, specialization, quality control, and memory — enabling a single developer to build production-grade software with the velocity of a small team.