A weekend with Claude Code

I spent the long weekend at my parents' place in Lahore and decided to rebuild the SkynetJoe theme site in Next.js 16 using nothing but Claude Code in the terminal. No Cursor. No VS Code Copilot. No Windsurf. Just a TUI agent with full repo context, a project memory file, and the ability to run shell commands directly.

Friday night to Sunday afternoon. Forty-six hours of wall-clock, maybe 22 hours of actual hands-on time once you subtract sleep, biryani breaks, and a four-hour Saturday morning where I rode out to a wedding in DHA Phase 8 and came back to find the tests had been running in a background process the whole time.

The outcome: a working, deployed site with about 60 routes, better Lighthouse scores than the v5.5 WordPress version it replaced, and a noticeably different mental model of what "programming" means in 2026. Here's what changed, what didn't, and where Claude Code still leaves me doing things by hand.

The new shape of work

The biggest shift isn't speed — though it's faster. The shift is that I stopped writing code and started writing prompts that describe code.The artifact I produce is a paragraph that says "build me a LetterArticle component that accepts these props, uses this CSS string, and renders a hero with caption, body, signature, and related cards." The artifact Claude Code produces is the file.

The intermediate step — where I would have hand-typed the TypeScript interface, then the JSX, then the conditional rendering — is just gone. I review the diff, request changes in English, and merge.

The implications take a while to settle. The first one is that the bottleneck in shipping became reading, not writing. Claude Code can produce diffs faster than I can carefully review them. The discipline is reading what it produced and pushing back when it's subtly wrong.

The five things that got dramatically faster

One: refactoring across many files. The single place Claude Code crushes a human is multi-file refactors. I asked it to rename a prop across 47 React components, update the consumer types, and run the type-check. Three minutes, one diff, zero typos. The same task in VS Code with find-replace would have taken me 25 minutes and produced two typos that would have shipped to staging.

Two: schema markup. Every page on the site needed JSON-LD schema — BlogPosting, FAQPage, Service. I had a vague mental model of what each schema needs and would have spent 90 minutes per type cross-referencing schema.org docs. Claude wrote the entire schema.ts helper module in under five minutes with accurate field coverage and the right conditional logic for optional properties.

Three: the boring parts of design system migration.Pulling the v5.5 WordPress theme's CSS variables into a Tailwind config, mapping the color names, translating the spacing tokens — Claude did all of this in one pass after I pasted the SCSS and asked for the Tailwind equivalent. The translation was 95% correct; I fixed the remaining 5% by eye.

Four: scaffolding new routes.Adding a new page in Next.js 16's App Router involves a directory, a page.tsx, a metadata export, optionally a loading.tsx and an error.tsx. Claude generates the whole scaffold from a one-sentence brief and gets the metadata canonical and OG tags right by inferring from neighboring routes.

Five: writing tests.Specifically the mechanical ones — render tests, prop-shape tests, snapshot tests. Claude writes these from the component file alone in seconds. The tests aren't world-class but they're better than the zero tests I would have shipped otherwise.

The five places it still doesn't help

One: deciding what to build.Claude Code is a build tool, not a product manager. The question of whether this page should exist, what its three sections are, and which CTA goes at the bottom — that's still my job. The agent will happily build whatever I ask. Asking for the wrong thing fluently is the new failure mode.

Two: design decisions with no precedent.When I asked Claude to design the V3 letter aesthetic from scratch, the result was generic — competent typography, safe color palette, no soul. Once I gave it a reference (the WSJ's longform format, mixed with a Substack-style serif body), it could match the reference well, but it couldn't invent the reference.

Three: anything involving real client data or production credentials.I won't let an agent touch production database credentials, Stripe keys, or live API tokens. The tradeoff is that anything requiring those needs a human in the loop, every time, and that human is the slowest part of the workflow.

Four: debugging weird runtime behavior.Compile-time errors get fixed beautifully. Runtime weirdness — the page that renders fine on desktop but blank on mobile Safari — requires me to open the actual browser, reproduce the bug, screenshot it, paste it back. The agent doesn't have eyes on the running app. The debugging loop is still mostly mine.

Five: the parts that require judgment about what "good enough" means. Claude will keep polishing forever if I let it. Knowing when to stop — when a component is 80% done and shipping is more valuable than the remaining 20% — is a judgment call that lives outside the agent.

The mental model shift

Programming used to be a craft skill where the bottleneck was your typing speed and your knowledge of APIs. The deep skills were knowing the language idioms cold and being able to hold the project's structure in your head.

With Claude Code in the loop, the bottleneck moves up the stack. The deep skills now are:

• Writing precise specifications.The difference between "build a navbar" and "build a navbar that's sticky on scroll, has a 16px-to-12px shrink animation, uses these three colors, and matches the rest of the design system" is the difference between shipping and not shipping.
• Reading diffs critically. The agent will introduce subtle regressions. The discipline of actually reading every line of every diff — not just scrolling past — is the new core skill.
• Architecture decisions.Should this be a client component or a server component? Should this state live in a context or a URL parameter? These are questions the agent can suggest answers to but can't make for you. Choosing wrong cascades.
• Knowing the codebase you didn't write.Claude builds it; you own it. If a client raises a bug six months from now, you need to actually understand the code well enough to diagnose. The temptation to ship code you don't deeply understand is real and has to be resisted.

The Saturday morning I rode out to that wedding and came back to find a test suite I'd set running with a single background-process instruction — that was the moment it clicked. The agent ran my entire test suite while I was at a wedding. I didn't have to be at the keyboard for 22-hour worth of work to advance by 30 minutes of agent time.— Field note, Sunday morning

Cost math

The 22 hands-on hours produced what would have been 3-4 days of conventional dev work for me. Call it a 2.5× speedup on a familiar codebase. The Anthropic API cost for the weekend was around $140 — meaningful, but trivial compared to the time saved.

For SkynetLabs client work, where the build is $4,000–$9,500 and the timeline is 14–45 days, the speedup collapses into earlier delivery and the ability to handle more concurrent retainers without adding headcount. The math isn't "Claude Code replaces a developer." It's "Claude Code lets one operator credibly deliver what used to require three."

What I'm changing about how I sell

Two specific changes to the SkynetLabs offer based on the weekend:

First, the Starter tier ship window drops from 14 days to 10 days, same price. The math is honest — the work that used to take 14 days now takes 10 because the agent compresses the boring middle. I'm passing the savings on as faster ship rather than lower price, because faster ship is what clients actually want.

Second, I'm adding a "take-home repo" clause to every contract. The Claude Code workflow produces extremely well-documented, well-typed code by default because that's what the agent emits. Clients now get a repo they could realistically hire any senior dev to maintain without a six-month ramp.

That second change is the bigger one. The vendor lock-in that's plagued agency work for two decades — "you can have the code but nobody will be able to read it" — finally has a structural answer. Agents produce code that a fresh human can read in an afternoon. That's a real shift.