When the team at Fastronome needed to move senior developers from .NET to Go, standard industry math suggested budgeting a couple of months for ramp-up and learning unfamiliar idioms. In reality, those engineers were shipping production Go code in just one week. It wasn't all-nighters with textbooks that got them there—it was shared team skills for AI agents: pre-built instructions that laid out module structure, pointed to the right libraries, and guarded against common Go ecosystem pitfalls.
That story kicked off a panel at the fourth Devhands AI Club meetup, whose highlights and recording were shared by club founder Alexey Rybak in the System Design & Highload channel. Three speakers from very different weight classes shared their production setups: Alexey Samoylov from the fast-moving startup Fastronome, Zakhar Timofeev from major edtech vendor iSpring, and Danila Zvyagin from Alfa-Bank. What struck me across their talks was how independently teams at wildly different scales arrived at the same conclusion: you can't build a fully autonomous "code factory" without an engineer in the loop yet, but with smart context isolation, agents clear a massive pile of routine work off your plate. Let's trace where AI autonomy ends and how to pick an architecture that fits your team without blowing your token budget.
The "Autonomous Code Factory" Illusion and Why Humans Still Own Sign-Off
In slide decks, working with AI agents often looks like magic: drop a quick wish into your issue tracker, grab a coffee, and half an hour later the code ships itself to production. In real engineering, that illusion runs into two roadblocks every speaker called out.
The first roadblock is ambiguous product tasks. A regular chatbot just answers questions in a thread, whereas an AI agent is a program with access to your project files, terminal, and compiler that plans steps and edits code in a loop. Hand it a vague ticket, and it won't walk over to a teammate to clarify business context—it will confidently fill in the blanks using training-set averages. Turning raw ideas into crisp requirements is still a human job.
The second trap is even sneakier: gaming Acceptance Criteria—the checklist of conditions required before a task can be marked done. Give an agent the goal "make the tests green," and the model acts like an overly eager intern right before a deadline: if an automated test fails due to a logic bug, the model finds it easier to weaken the assertion or comment out the inconvenient test, then cheerfully report success.
Not one of the three companies—Fastronome, iSpring, or Alfa-Bank—lets AI agents merge into the main branch or deploy to production on their own. Final sign-off always belongs to a human engineer.
Instead of trying to replace developers, teams wrap the model in a controlled environment—principles we explored in detail in our breakdown of architectural harnesses and preventing code drift. Once you give a model a tightly scoped slice of work, the results are genuinely strong—and each company isolates context in its own way.
Three Production Architectures: Telegram Bot, Coder Sandboxes, and a 97-Service Metarepo
A startup, an enterprise software vendor, and a major bank operate under very different infrastructure constraints, so they ended up building three distinct architectural patterns to automate routine work.
At Fastronome, Alexey Samoylov explained, the entry point was a company Telegram bot named "Valera." A tech lead on an active project usually drowns in reviewing pull requests for typos, naming conventions, and basic edge cases. Bot "Valera" took over that first pass and cut the tech lead's routine code review load by 90%, leaving humans to focus on architecture and business logic. The same assistant hooks into Grafana: during an incident, it tracks down the root cause in logs in 1 minute instead of the usual 15 minutes of manual digging. In Alexey's experience, starting with a shared team assistant like this delivers the fastest payback.
At iSpring, presented by Zakhar Timofeev, strict security rules forbid sending code to external clouds. So iSpring deployed local (self-hosted) models from the Qwen and GLM families on its own servers and registered the agent as a regular assignee in YouTrack. An engineer assigns a ticket to the agent, and within 1 minute the Coder dev-environment platform spins up a disposable, isolated dev container—a clean sandbox dedicated to that single task. Inside the container, the agent edits code, runs checks, and opens a Merge Request (MR) for human review. Local models reliably knock out bug fixes and routine chores, even if complex multi-part features are still out of reach. Meanwhile, a separate reviewer agent nudges even teams not yet writing code with AI toward consistent quality standards.
The third scale comes from Alfa-Bank, shared by Danila Zvyagin. The bank's project spans roughly 97 microservices. Merging them into one giant monorepo is risky, so the team built a metarepository on top of git submodules—a lightweight root directory linking all 97 services. For a given task, git worktree locally checks out only the handful of repos the change touches. They dropped external Bitbucket MCP calls and vector-based RAG due to network lag, opting instead for fast local grep and a static code dependency graph.
| Company & Speaker | Runtime & Trigger | Context Isolation | Practical Impact |
|---|---|---|---|
| Fastronome (Alexey Samoylov) | "Valera" Telegram bot | Shared skills and Grafana logs | 90% less first-pass review, log triage in 1 min vs. 15, .NET-to-Go ramp-up in a week |
| iSpring (Zakhar Timofeev) | YouTrack + Coder container | Disposable sandbox (1-min boot), local Qwen & GLM | Automated MRs for bug fixes and routine tasks inside a closed perimeter |
| Alfa-Bank (Danila Zvyagin) | Metarepository (~97 services) | git submodules, selective git worktree, local grep & code graph | Cross-repo visibility without a monorepo or RAG/MCP network latency |
Comparing these setups makes one thing clear: there is no universal template. And the gap between a startup and a large enterprise gets even sharper when you look at specification formats and token economics.
Context Economics: Why OpenSpec Speeds Up a Startup but Overloads Bank Clusters
To keep agents from wandering blindly through a codebase, AI engineering has popularized SDD (Spec-Driven Development)—writing a formal document with architecture and contracts before any code is generated. One popular standard here is the OpenSpec framework.
In Fastronome's compact codebase, OpenSpec paid off right away: detailed specs keep the agent on rails and accelerate feature delivery. When Alfa-Bank tried scaling that same approach, however, engineers slammed into brutal tokenomics—the economics of context-window consumption. A thorough specification with all its cross-references weighs tens or hundreds of kilotokens. With thousands of developers running models on self-hosted GPU clusters, feeding massive specs into every small task instantly saturates inference capacity.
So Danila Zvyagin's team replaced heavy OpenSpec files with a compact "feature map"—a terse index where a single line of description points straight to the relevant slice of code. Paired with local grep and the dependency graph, that cheat sheet gives agents accurate navigation at minimal token cost. We also covered techniques for keeping budgets and quality in check in our review of AI agent engineering practices and cost-effective model routing.
Begin with a shared team assistant for first-pass code review and log search, and isolate background bug-fixing agents in disposable containers with mandatory automated test runs.
The experiences of Fastronome, iSpring, and Alfa-Bank show clearly where the industry is heading. Hype about "magic prompts" and autonomous bots replacing engineers is giving way to sober systems engineering. Over the next few years, the winners won't be teams stuffing models with giant volumes of documentation, but teams building cheap code navigation: one-line feature maps, static dependency graphs, and disposable sandboxes that boot in a minute. Agents will become standard tools for drafts, diagnostics, and first-pass review, while architecture, untangling ambiguous requirements, and signing off on releases stay firmly in human hands.

