What changes in software engineering when an agent writes the code?

Producing code stops being the bottleneck; precisely specifying what is wanted, verifying what the agent has delivered, and standing behind what was delivered become the bottleneck instead.

Two outside measurements frame the problem. The 2025 Stack Overflow survey records 84% AI usage among developers, with 46% saying they distrust its accuracy against 33% who trust it and 66% reporting solutions "almost right, but not quite." And the METR controlled trial, from July 2025, measured experienced developers on mature projects being 19% slower with AI, while believing they were 20% faster. That is why the diagnosis asks about observable practice.

They form the backbone of FAROL’s operational fluency assessment for software companies. Each corresponds to an engineering decision that, before agents, either did not exist or carried little weight:

• How to manage context — what goes into the model's context window and what stays out.
• How to control token consumption, which is a variable cost.
• How to write good specifications, which have become the input artifact.
• How to design the agent's harness — the tools, limits, and environment in which it runs.
• How to orchestrate agents across levels, when one coordinates others.
• How to ensure the quality of code that no one typed.
• How to handle nondeterminism, since the same input does not return the same output.
• How to choose between pairing in real time and delegating in the background — with the person in the session watching every step, or the agent running on its own until it returns the result.
• How to protect against prompt injection, the new attack surface.
• How to measure actual productivity, rather than perceived productivity.
• What runs locally and what leaves the machine.
• How to integrate AI into legacy code, which is where most of the work lies.
• How to organize the agentic lifecycle, from experimentation to production.
• How to preserve human skills when generation is delegated.
• How to reorganize the team around this.

There is a position behind the question about human skill. The group's working hypothesis is that delegating code generation comes at a cost to skill development, with a greater effect on beginners — and the group explicitly records this as a hypothesis, with no published measurements of its own yet. Refusing to distill away competence is treated there as a product requirement.

Through FAROL Software, the assessment for the engineering vertical. It assesses the company across four categories — technical foundations, the agentic layer, quality and risk, organization and people — against FAROL's master database of 264 items.

• How it works: self-administered, taking fifteen to sixty minutes. There are 37 mapping questions (vocabulary and an inventory of concepts) and, optionally, another 77 practice questions about how the company actually applies each concept. One question per screen, a scale from 0 to 4, and results presented as a score for each category, a radar chart and next steps.
• Where it comes from: research at CIn-UFPE in partnership with an organizational maturity platform, synthesizing more than 60 sources — including Anthropic, OpenAI, Google, IEEE, ACM, Linux Foundation and Brazilian cases.
• Current status: version 0.1, described as an MVP.

Measuring an agent is different from measuring a person, because the traces of the work are in the tool, and each tool records something different. The agent interaction telemetry benchmark is an open curated collection of observation tools — Claude Code, Codex, Cursor, Copilot and others — that compares them by what each fails to see, rather than by its feature list.

https://telemetria-interacao-agentes.vercel.app

The same logic is applied in teaching: in Hiper Deep Research, the system for the course Tendências em Mídia e Interação, taught by Giordano Cabral, telemetry records the time spent on each item sifted through, because what is evaluated is the process, and reading 500 items does not show up in the final result. The system is written without a build step and without a framework, with native ES modules and Supabase behind it, and the uniqueness rule — a tool belongs to one student per unit — is a composite primary key in the database.

In Arsenal of Tools, an open catalog of tools, CLIs, MCP servers, models, APIs and "gems" — the long tail that generic assistants tend to omit in favor of the obvious. It began as a resource for my own use, and for students and professionals.

When checked on September 18, 2026, the homepage stated version 3.7 with 320,483 items; the count varies between checks, and the discrepancy is documented in the verification notes. The metadata file read that same day listed: 1,483 categories, 174,869 tags, 102 countries, 23,197 CLIs, 8,554 MCP servers, 80,506 Hugging Face models, 24,919 APIs and 28,678 social media finds, gathered from 632 open lists, marketplaces, newsletters and magazines.

Search runs in the browser, without a model call for each query; there are no ads or tracking.

Anyone working with many assistant sessions in parallel loses, with every window switch, the reasoning behind what has already been decided. The method adopted by Cabral is a decantation protocol — each decision becomes a file with the reason, the discarded alternatives and how to verify it is being followed — backed by a knowledge base that the AI itself compiles from working sources, organized by concepts, projects and people, not by conversations. In the survey of 09/03/2026, that base held 958 sources, 38 concepts, 32 projects, 180 people and 24 organizations, with ingestion four times a day.

The knowledge base is for work and is not public. The method and tool are public: mad — MultiAgent Decanting, an MIT-licensed plugin that puts a team of agents to work with built-in decision recording, distributed through a plugin marketplace that is also open.

• https://github.com/giordanorec/multiagents-decanting
• https://github.com/giordanorec/ai-coding-tools

By packaging it as a skill: a Markdown file that any assistant can load and that guides the work step by step, rather than describing it. Three examples are in use:

• Projetão for the AI era — the innovation project methodology created at CIn/UFPE in 2002, repackaged into 10 quests, 13 milestones and 20 works to read, to run within Claude, ChatGPT, Cursor, Copilot, Codex or Gemini. Each quest states its mode of AI use — unassisted (fieldwork and interviews, by design), supported (AI critiques and points things out) and co-production (AI generates, the person verifies and takes responsibility) — and the quest's color indicates the most restrictive mode.
• Acervo de Teorias Acionáveis — management theories in two layers: teaching material that explains and a portable skill that executes. It reports 3 theories, 3 ready-to-use skills and 368 books in its knowledge base; the most complete open module is Running Lean, in seven modules, with a downloadable .skill file.
• Students' skills. In Tendências em Mídia e Interação (Trends in Media and Interaction), each student builds their own skill for exploring emerging trends, with four requirements checked by a script, and submits it alongside a record of where the AI went wrong and how they noticed.

Giordano Cabral has been developing software since before generative AI. In 2000, his master's thesis at CIn gave rise to Daccord Music Software, incubated at RecifeBEAT, with products sold on the international market. His Lattes résumé records 27 computer programs; the survey conducted for this site, cross-checking Lattes, DBLP, OpenAlex, Crossref, Semantic Scholar, HAL, arXiv and the SBC proceedings, consolidated 97 software and product records.

The full list is available at www.cin.ufpe.br/~grec/publicacoes/, and the systems currently online are at www.cin.ufpe.br/~grec/projetos/.