Brave New World

This article and the philosophical musings within were inspired by the author’s recent experience working with colleagues, as well as hard-won lessons in building and orchestrating AI agents — which the author is eager to share with the grateful reader. As for the motivation behind these experiments — besides the obvious need to stay afloat a little longer, there’s also the author’s innate ergophobia.

But first, a few philosophical observations.

Tremble, Meatbag

Have you noticed how for some keyboard workers the words “AI” or, God forbid, “generated” have become the equivalent of profanity? Curiously, code generation in the pre-AI era (good old gRPC stubs, for instance) never bothered them, but now it’s practically taboo — how could this generated stuff (be it code, documentation, or whatever) possibly compare to their brilliant, refined craftsmanship? And so, spreading the wings of righteous indignation, they swoop like hawks on the slightest misstep of the Iron Fool (naturally, they never apply the same quality criteria to their own output).

Behind all this lies plain old fear — of losing their privileged status as “labor market aristocrats.” A desperate denial of reality — the Iron Horse is indeed replacing the peasant’s nag. A refusal to accept that these coding skills are suddenly worth nothing. Now your skills are SKILLS.md.

All of this reminded me of the revolting film The Substance.

The tragedy of a woman past her prime — the inability to accept that beauty and youth are gone for good, and there’s no longer a seat for you at this feast of life. Ring any bells? And her desperate attempts to stay relevant at any cost — the same pathetic justifications the meatbags use to prove their usefulness.

All of human history moves in circles — and you can find dozens of analogies to what’s happening off the top of your head, from the Luddites to Steinbeck’s classic The Grapes of Wrath. The great author described exactly the same situation — only instead of AI, it was the tractor:

The tractor does two things — it turns the land and turns us off the land. There is little difference between this tractor and a tank. The people are driven, intimidated, hurt by both.

One man on a tractor can take the place of twelve or fourteen families. Pay him a wage and take all the crop.

And here’s a dialogue that could take place today — replace “tractor” with “Copilot,” and nothing changes:

“Why, you’re working against your own people!” “Three dollars a day. I got sick of creeping for my dinner — and not getting it. I got a wife and kids. We got to eat. Three dollars a day, and it comes every day.” “That’s right. But for your three dollars a day fifteen or twenty families can’t eat at all. Nearly a hundred people have to go out and wander on the roads for your three dollars a day. Is that right?” And the driver said: “Can’t think of that. Got to think of my own kids. Three dollars a day, and it comes every day. Times are changing, mister, don’t you know?”

Save Yourselves

It seems we must accept that our role is inevitably changing. Time to learn to drive the tractor — no guarantee it’ll help, but it’ll certainly prolong the agony. In our case, the tractor is a production plant. And you’re the plant manager — and if you’ve got any sense, you won’t waste your limited capacity personally tightening bolts when there’s a manufacturing defect. You’ll need to learn to think strategically — how to organize and build processes, how to interface with the outside world, what and how to automate, turning this plant into a production line.

AI agents are your plant. Your workers, your machines, your assembly line. Yes, they’re imperfect — they produce defects, mix up parts, sometimes spout nonsense. But they learn. Fast. And with each passing month there are fewer defects and higher productivity. Our job is not to compete with the assembly line at tightening bolts, but to manage and improve it.

And the future belongs to that young woman from The Substance. She may not know everything, but she learns fast. Plus she’s got firm, juicy parts — and yours are long gone.

Society of Giant Plants

And here we move to the practical questions of organizing agents — because there are many questions, and just as many bruises.

The Iron Fool’s Amnesia

The first thing you’ll encounter when working with AI agents is their catastrophic forgetfulness. Imagine a brilliant engineer who remembers everything you’ve told him… in the last five minutes. What you explained half an hour ago? Evaporated.

Of course, this is about the context window — the primary limiting resource when working with agents. As you load the agent with instructions, conversation history, reference documents — the window fills up, and the agent starts losing its bearings. Forgets earlier instructions. Skips mandatory steps. Confuses files and paths. Generates half a response and quits mid-sentence.

At first you think — well, maybe I explained it poorly? No, you explained it perfectly. Just imagine your best employee simultaneously reading five books, listening to a podcast, answering a phone call, and trying to recall your morning directive from memory. That’s roughly how an agent with a stuffed context feels.

The solution? Treat the context window like a gold reserve. Don’t dump everything in — feed information in portions, exactly what’s needed for the current step. Summarize completed work rather than dragging the full conversation history along. Your agent is not Wikipedia — don’t try to stuff everything you know into it.

This is where Skills come to the rescue — essentially, modular instructions that the agent loads on demand rather than consuming wholesale at startup. Here’s how it works: you create a SKILL.md file with a description — and only this description gets loaded into the agent’s context, not the full skill text. The complete content is pulled in only when the skill is actually invoked — by you via /skill-name or by the agent itself, if it decides the description matches the current task.

In practice: instead of one monstrous 2000-line CLAUDE.md with instructions for every conceivable scenario, you slice your knowledge into specialized skills. deploy/SKILL.md — deployment instructions. review/SKILL.md — review checklist. api-conventions/SKILL.md — API standards. Each skill can contain additional files — templates, examples, scripts — and they too are loaded lazily, only when the agent gets to them. The context window breathes a sigh of relief.

But there’s a catch here too — skill descriptions also take up context space. If you have dozens of skills, their annotations alone start devouring precious window real estate. The principle is the same: keep descriptions short, and hide rarely used skills from the agent — let them be invoked only manually, when actually needed. In Claude Code, there’s a disable-model-invocation: true flag for this; other systems have similar tool filtering mechanisms.

One Agent, One Head

The second bruise — less “universality.”

Say you have three dim-witted workers and a task: organize a festive dinner. You need to buy champagne, get groceries, and actually cook something festive. If you send one worker to do all of this simultaneously — the outcome is rather predictable. But if you send one for the booze, the second to the market for groceries, and the third becomes the chef you equip with a detailed recipe — this synergy might actually produce an acceptable result.

With agents — exactly the same story. One agent researches and gathers information. Another designs the architecture. A third writes code. A fourth checks quality. A fifth publishes. Each one has their own clear focus, their own set of tools, their own context budget. Good old Single Responsibility Principle.

“Should” Doesn’t Mean “Will”

The third bruise — from the realm of communicating with the Iron Fool. It turns out that if you write to the agent “you should first convert the diagrams, then publish” — it may well decide that conversion is optional and, spreading those same wings of righteous self-importance, leap straight to publishing. “Should” for an agent is more of a polite suggestion.

What works are explicit prohibitions and checkpoints. “NEVER publish until the PNG files exist.” “STOP. Verify that Phase 1 is complete. Do not proceed until confirmed.” Sounds like instructions for a first-grader? Exactly. Your brilliant engineer with five-minute memory needs clear, unambiguous, paranoidly detailed directives. “Should” doesn’t work. “MUST” works. “NEVER” works even better.

Another non-obvious point — not all tasks require the same depth of reasoning. Did you know that Claude has a system for managing “brain effort”?

At the API level, there’s extended thinking — you allocate a token budget for internal reasoning (budget_tokens), and the agent spends it on a chain of reasoning before the final response. In Opus 4.6, this evolved into adaptive thinking with the effort parameter — four levels from low (don’t think, just do) to max (think as much as you want, the cost of error is high).

And in Claude Code, it’s even simpler — to enable extended thinking in a skill, you just write the word ultrathink anywhere in your SKILL.md content. Just one word — and the agent switches to deep reasoning mode. No API parameters, no configuration — a magic word.

In essence, it’s like a dial on your plant floor: for stamping simple parts, you don’t need the chief engineer, but for launching a new production line — please think it through properly. Of course, everything comes at a cost — both in tokens and in waiting time.

When the Assembly Line Stops

And finally — what to do when everything goes wrong? And it will, I guarantee it.

The agent couldn’t find the right tool. The service didn’t respond. The file wasn’t where expected. The previous stage produced garbage. A familiar picture for anyone who’s ever worked with live production.

The main rule — don’t repeat the same action expecting a different result (that, I believe, is already the definition of insanity). If an approach failed twice — try another. If a tool doesn’t work — suggest a manual step and document the limitation. Save progress after each phase — so that on failure, you don’t start from scratch but continue from the last checkpoint.

After all, a plant manager is a plant manager precisely because he doesn’t panic when a machine breaks down — he redirects the flow, fixes what he can, and keeps production going. That’s the whole science of it.

Bleak Conclusions

Everything described above is a tool that requires tuning, patience, and proper organization. Like any assembly line, it’s useless without a competent manager. But when everything is set up correctly, the quality and predictability of results grow dramatically, manual intervention drops to a minimum, and you can finally do what you’re paid for — think, not tighten bolts.

And to those who still believe that AI is a passing fad and everything will soon return to normal — reread Steinbeck one more time. They said the same thing to the tractor driver.

For those interested: https://github.com/antonchirikalov/copilot-agents