C abstracted assembly. C++ abstracted C. JavaScript abstracted memory management. Each layer let humans think at a higher level. The same leap just happened again — the new abstraction layer is English.

The language I work in now is English. Whether the target is TypeScript, Rust, or Python — source code is a lower-level artifact generated from higher-level intent. I write close to 0% of code by hand. I write documentation and sophisticated prompts.

I wrote a deep dive on this with the full AfterPack case study. Here I want to focus on the practical workflow — what changed and what it means for anyone building software, whether you're writing code, leading a team, or making product decisions.

The Mental Model

Every AI tool boils down to:

Input + Context → LLM → Output

Quality of output is directly proportional to quality of input. I've watched the same LLM give a junior mediocre code and a senior production-ready architecture. The difference was entirely in the context provided — and that applies whether you're prompting for code, system design, or go-to-market strategy.

The Full Lifecycle Changed

If you're only using AI for code autocomplete, you're at maybe 10%.

Ideation and Research: Pressure-test ideas across multiple models (Claude, Gemini, GPT — trained on different data, they spot different blind spots). Competitive landscape analysis. Demand validation with real data. Hours, not weeks.

Planning and Architecture: Where I spend the most time — significantly more than on implementation. Load context: existing architecture, constraints, business requirements. Ask for multiple approaches. Have it argue against its own recommendations.

Planning mode is king. Days in planning, then execution in ~30 minutes. It self-tests. When I come to QA — it mostly just works when planned right.

Design: Skip Figma for many use cases. Give the LLM your existing UI and design system — 15 minutes later, new pages match your patterns. Pro tip: Gemini Pro creates better initial visuals, Claude handles long-term code evolution far better.

Implementation: The fastest part of the cycle. Refactor 100+ files by new design patterns — one-shot in 10 minutes. Previously a week of tedious work.

Testing: AI writes tests, runs them, interprets failures, fixes code. But on real products, you spend most time here — verifying outputs, applying judgment.

Your Brain Goes TikTok

Nobody warned me about this. When AI handles implementation this fast, you become the bottleneck. So you try to keep up — I run 3-5 Claude terminals in parallel. One auditing a codebase, another implementing an API, a third writing product specs. Constantly jumping between contexts, reviewing, catching mistakes.

It's incredibly brain-intensive. Coding used to be more relaxing — hold one idea for 10-20 minutes, type it out, move on. Now you're a rapid context-switcher. TikTok was training us for this all along.

The Real Bottleneck: Human Synchronization

Your role becomes judge, architect, quality controller. But the deeper bottleneck isn't you individually — it's human synchronization. Meetings, handoffs, miscommunication, waiting for approvals. When execution takes 30 minutes, spending 3 days aligning on requirements is the dominant cost.

Who thrives:

• Solo builders shipping entire products alone
• Small teams with clear ownership and less meetings
• Senior generalists who own entire feature areas — PM, QA, architect, engineer in one

One person carries what previously required a team. For larger organizations, each person's blast radius is dramatically larger than two years ago.

The AfterPack Story

I'm building AfterPack — a Rust-based JavaScript obfuscator. Three weeks on core architecture, not a single line of Rust.

1. Documentation first. 20+ spec files. Different AI agents on different parts of the spec — just careful system design.
2. JavaScript prototyping. Prototyped obfuscation transforms in JS. Multiple iterations. Agents tried to break the prototypes and suggested improvements.
3. Adversarial testing. Claude Code running overnight: "keep iterating until a fresh Claude instance can't deobfuscate the output."

Production Rust — a language I'd barely touched. My language is English. I focus on architecture, data structures, algorithms. The previous generation of JS obfuscators took 2-3 years. I'm shipping something more advanced in a fraction of that time. I experience the same compression with DataUnlocker — years of work, now condensable into months solo.

What Actually Matters

1. Context is everything. Write documentation before anything. What you want, why, constraints, what "good" looks like.
2. Start in planning mode. Multiple approaches. Model argues against itself. Prototype in simpler language first.
3. Use multiple models. Claude, Gemini, GPT — different training, different perspectives. Critical for planning.
4. Own the architecture. AI implements whatever you describe. Your job is describing the right thing. That won't be automated anytime soon.

Where to Start

• New to software: AI assistant + plain English. You'll learn from watching it reason.
• Not using AI yet: build your next feature entirely AI-assisted.
• Already using AI daily: better documentation, more planning mode, focus on context quality.
• Leading a team: biggest gains are in reducing coordination overhead, not individual speed. Rethink whether every meeting is still necessary when execution is this fast.

Originally published on nikitaeverywhere.com