The Poetry of Agentic Development: How to Code with Agents When Ease Breeds Complexity

Ease vs. simplicity

Habr author arturdumchev has been coding with agents every day for a year and a half and offers a fresh take on AI-assisted development. His thesis: agents let you write code fast, but responsibility for mistakes stays with the developer, and the resulting systems often end up overly complex.

The core distinction is between easy (subjective, depends on experience) and simple (an objective property of a system). Russian is easy for a native speaker but hard for a foreigner. Complexity, meanwhile, is the intertwining of independent aspects — literally 'multi-foldedness.' DRY can be a code smell, but sometimes duplication actually simplifies a system and reduces coupling.

Vibe coding with agents is very easy, but the resulting systems are often complex. The developer bears full responsibility for the LLM's code, and the more complex that code is, the harder it is to understand, the lower its reliability, and the weaker the guarantees around time-to-market and SLAs.

Does the LLM understand complexity

The answer is mixed. Research shows that models are good at reasoning about complexity but bad at avoiding it.

List of studies: • τt-Bench: agents automate code writing but not engineering judgment. When a test fails, the agent fixes the test rather than the code. They ignore production requirements, reusability, and architectural boundaries.

• SlopCodeBench: LLMs produce 2.3x more lines of code than humans. Degradation on the structural erosion metric (complexity accumulating within functions) is roughly 6x.

The best-performing model in the experiments was GPT-5.5. • Estimating problem difficulty: the correlation between LLM and human difficulty ratings is 0.

8 (Pearson). • Can LLMs Estimate Student Struggles: models don't adapt to a specific person's experience level and don't predict individual struggles. • Rethinking Code Complexity: a study of complexity through nesting depth and branching.

• Beyond Strict Rules: DeepSeek-R1, GPT-5 mini, Llama-3.3, and Qwen2.5-Code catch simple code smells, but miss more complex ones that are visible to humans.

• The Modular Imperative: Claude Sonnet 4 splits code across files and writes about separation of concerns, but in doing so implicitly links entities and tangles the system.

Balancing control and autonomy

There are two extremes: full control (the developer does everything, complexity is minimal, but effort is maximal) and full autonomy (the agent writes everything, effort is zero, but complexity grows). Graphically, this relationship is inverse.

The author suggests there's an optimum point beyond which further investment of effort yields diminishing returns (the law of diminishing returns). For example, after writing a template for 50 similar tests, you've spent a lot of effort, but the agent can then replicate them by analogy on its own — the value was concentrated in that first 20% of effort.

Formally, finding the ideal balance is impossible — it depends on the project's context, its evolution, the team, and the requirements. But empirically, the author has arrived at a set of principles grounded in code maintainability values: deeper control over architecture, explicit separation of responsibilities, and minimizing accidental complexity.

Not a single line of the article was written by an LLM. Agents were used only to search for information, check for errors, and generate text diagrams. Every word was typed by hand.