The sky outside the window has finally cleared up. At 13 or 14 degrees Celsius, Shanghai is showing rare early signs of spring. Taking advantage of the nice weather, let’s talk about something hardcore.
One Person Taking on a Platoon is No Joke
I wonder if you’ve noticed, but over the past two years, there has been far too much noise in the market about “how to write code with AI.” But last night, while browsing GitHub, I stumbled upon an open-source document titled A Practical Guide to the Era of AI Programming, and it kept me reading for hours straight.
This guide was put together by two developers named Lanxi and Demon King Akanazi, who recently merged a major 2026 revision. It spans a massive 16 chapters and 130,000 words. The detail that struck me the most wasn’t their recommendation of some earth-shattering new model, but the fact that the entire book is literally split in half—every single workflow is strictly categorized into two perspectives: “OPC (One-Person Company)” and “Team (3-5 person collaborative teams).”
Simply put, even when using Cursor or Claude Code, the posture of an indie developer versus a special ops team is entirely different. For a solo developer in a cafe, spinning up an authentication system with a single prompt relies on a minimalist setup of 1-2 tools and a single source of truth. But with five people, how do you manage prompt versions? How do you squeeze AI code reviews into a CI/CD pipeline? This kind of discrepancy has rarely been laid out so transparently before.
Giving Permissions to AI: Do You Dare Close Your Eyes?
Speaking of this, I’m reminded of having tea a few days ago with an architect friend at a top-tier tech giant. He complained endlessly about how current business teams are blindly stepping into pitfalls when using AI.
The Guide dedicates an entire chapter to MCP (Model Context Protocol). Many people are now using Cursor Background Agent for autonomous coding, thinking it’s exhilarating to let AI automatically run refactoring in the background. But there is an unavoidable underlying issue: where exactly should the boundary of AI’s permissions be drawn?
Just look at this architecture diagram and you’ll understand: MCP decouples data sources and tools, which is essentially a battle for control over context.
From the lone-wolf perspective of an OPC, MCP is just a simplified integration tool—an end-to-end pass yields the highest efficiency. However, once you switch to the Team perspective, MCP fundamentally solves permission governance. You can’t possibly give a shared public AI Agent direct read/write access to your production database, right? So in team collaboration, AI’s decision-making power must be granted through tiered authorization, and its outputs must be auditable and traceable. It’s very much like setting permissions for a newly hired intern—you have to keep an eye on them, except today’s “intern” can modify 300 files in a single second.
Don’t Just Envy the Glory, Look at the Pain
Let’s do a horizontal comparison of the current tool ecosystem. Terminal-based Claude Code, the GUI-equipped Cursor, and the multi-sandbox parallel OpenAI Codex have basically carved up developers’ habits completely.
To put it bluntly, those online tutorials teaching people how to “generate an APP with zero basics in one click” are essentially intentionally avoiding engineering complexity.
One of the most honest aspects of this guide is its die-hard commitment to TDD (Test-Driven Development) in the testing chapter. Without reliable unit tests acting as a quality gate, the speed at which AI generates code is exactly the speed at which you produce garbage code. If you write business logic at 10x speed, you’ll end up spending 100x the time debugging.
Furthermore, there’s an extremely realistic cost issue. Every time you invoke Opus 4.6 or other flagship models, the API bill is very real. That’s why the book specifically discusses using a Memory Bank for personal management of context compression. After all, if you don’t budget carefully, the monthly cost of running AI might end up being more expensive than renting your own servers.
An interface like this, autonomously running tests and modifying code in the background like crazy, probably makes anyone who has used it feel both excited and terrified.
I Sometimes Wonder, What Will Junior Engineers Do in the Future?
There’s a particularly chilling line in the FAQ section of the book: “This book is not for complete beginners. We assume the reader has basic programming experience.”
How should I put this? If a 3-5 person special ops team, equipped with an AI agent cluster, can now output the workload of a traditional 25-person team, then the 20 displaced roles will highly likely belong to junior developers.
I sometimes wonder: if our generation grew up by hand-coding CRUD operations and staying up all night reading open-source code to debug, what about the next generation of developers? If the system architecture is broken down by AI, detailed specs are generated by AI, and even code reviews are completed by cross-models nitpicking each other, how will human engineers accumulate that intuition for complex systems? Or maybe I’m overthinking it. Perhaps, just as we no longer hand-write assembly language, future engineers will simply stand naturally at a higher layer of abstraction to assemble the world.
The Coffee is Cold
Without realizing it, the latte next to me has gone completely cold, with a layer of oil floating on the surface, looking a bit cloying.
This MIT-licensed document is still being updated. Rumor has it they just integrated the “Lanxi Story” into Chapter 16, which is quite interesting. If you happen to be getting a headache over how to standardize your current AI tools, or are just curious about how the wildest indie developers are actually working nowadays, you can go dig through its workflow checklists—they are plug-and-play anyway. As for whether you should choose the lone-wolf mode or the team mode, don’t overthink it. Either way, in the end, you’ll have to deal with those tireless code machines.
References:
- bestcarly/opc-coding-guide (GitHub 2026)
- Anthropic’s Model Context Protocol (MCP)
- Exploring Cursor Background Agents: A Hands-On Experience
—— Lyra Celest @ Turbulence τ.
