For the month of March 2026, I went all-in on Claude Code — Anthropic's CLI tool for AI-assisted software development. Not as a side experiment, but as my primary development workflow across everything: web apps, enterprise platform development, client demos, and business automation. Here are the real numbers and lessons from that experience.
The Setup
Claude Code is a command-line tool that connects an AI directly to your codebase. It can read files, write code, run terminal commands, search your project, and spawn sub-agents for parallel work. Unlike chat-based AI assistants, it operates in your actual development environment — reading real files, running real builds, making real commits.
I used it across five workstreams simultaneously: full-stack web development (Next.js/TypeScript), enterprise platform development (Apex, Lightning Web Components, CI/CD pipelines), interactive client demos, business automation (Slack bots, email workflows, API integrations), and financial content writing.
How I Actually Used It
My approach was deliberate: treat Claude Code as a development team, not a coding assistant. I'd give broad, high-level directives — “build 25 SEO pages with full metadata and internal linking,” “refactor these components and ship the PRs,” “build a cinematic demo site for this client pitch” — and let it execute autonomously while I moved to the next thing.
I averaged 6+ sessions per day, often running multiple in parallel. 32% of my messages were sent while another Claude session was already running. The interaction style was iterative and reactive: launch fast, review the output, course-correct. I rarely wrote detailed specs upfront.
“The key insight: AI coding isn't about getting it right the first time. It's about iterating so fast that wrong answers barely cost you anything. A human developer might take 2 hours to build a page. Claude builds it in 3 minutes. Even if I reject it twice and it takes 3 tries, I'm still way ahead.”
What Worked
1. Mass Content Generation at Scale
In my peak session, I shipped 175+ fully-formed pages — each with SEO metadata, structured data, internal linking, sitemap entries, and search index wiring. The pattern: describe the template once, give Claude a list of topics, and let it run. I orchestrated this through parallel “agent waves,” spawning 3–4 sub-agents simultaneously. On a good day it looked like a one-person content team outputting the work of five.
2. Enterprise CI/CD Sprints
My biggest sprint: 22+ pull requests and two package versions shipped in 8 hours. Claude handled the full workflow — reading existing code, making changes, updating test classes, creating PRs, debugging CI failures, and re-submitting until green. The key was letting Claude own the iteration loop. Instead of me debugging each CI failure, I'd point it at the error output and say “fix it.” Sometimes it went through 5–7 cycles to get a single PR green. Tedious for a human, trivial for an AI.
3. Cinematic Client Demos Under Deadline
I used Claude to build interactive proposal websites — not slide decks, but fully functional web apps with animations, data visualizations, interactive demos, and embedded mini-games. Each iteration cycle took about 3 minutes, which meant I could explore creative directions that would be too expensive to try manually. Every demo shipped on time.
What Broke (Full Transparency)
This isn't a puff piece. 139 things went wrong across 170 sessions. Here's the honest breakdown:
Buggy Generated Code
68 incidentsUndefined properties, incorrect method signatures, API methods that don't actually exist, and framework syntax unsupported in the version we were running. Each required 2–3 iteration cycles to fix.
Wrong Initial Approach
49 incidentsTargeting the wrong environment, building features nobody asked for, committing directly to main instead of using the PR workflow, or jumping ahead before confirming the approach.
Parallelization & Deploy Conflicts
22 incidentsMultiple sessions fighting over git locks, competing commits, and cascading deploy failures. Running parallel AI sessions is powerful but requires careful coordination.
Despite all 139 friction incidents, 94% of session goals were still achieved. The friction is real but manageable. The question isn't “does AI make mistakes?” — it's “does AI make mistakes fast enough that the net output still crushes manual development?” The answer is yes.
Lessons Learned
Iteration is the strategy, not a failure mode
Getting it wrong the first time isn't a problem when iteration takes 3 minutes. A human fixing 139 bugs would take weeks. Claude fixed them in the same sessions they occurred.
Constraints must be stated, not implied
Claude doesn't know your deployment workflow, your branch strategy, or which environment you're targeting unless you say so. A 30-second briefing at the start of each session prevents most wrong-approach incidents.
Parallelism needs traffic control
Running 6+ sessions per day is incredible for throughput, but only if they don't step on each other. Dedicated branches, batched commits, and never letting two agents push to the same repo at the same time cuts deploy failures dramatically.
Multi-file changes are the killer feature
The ability to edit 10+ files in a single action — updating a component, its tests, its imports, the sitemap, and the search index all at once — is where AI development pulls furthest ahead of manual coding.
Where This Is Heading
We're at the inflection point between “AI as coding assistant” and “AI as autonomous development pipeline.” The workflows I ran manually — spawning parallel agents, managing branch isolation, debugging CI failures — will be orchestrated automatically within the next year.
The implications for small teams and solo developers are enormous. One developer with well-orchestrated AI agents can already output what used to require a 5-person team. As these tools mature, the bottleneck shifts from coding capacity to product vision and architecture — the parts that require genuine human judgment.
The developers who learn to steer AI effectively now — who build the muscle memory for iteration-over-perfection and learn to manage parallel agent workflows — will have an enormous advantage as these tools get better. The gap between AI-native developers and everyone else is going to get very wide, very fast.
Full Interactive Breakdown
The complete analysis with interactive charts, tool usage data, time-of-day patterns, and detailed deep dives on each workflow.
View the Full Case Study →