AI development is moving from autocomplete and chat toward command-line agents that can handle end-to-end software workflows.
2
Enterprise code needs context, testing, review, maintainability, and company practices alongside code generation.
3
A command-line interface lets developers connect agents and workflows, pass results between them, and run different interfaces for different tasks.
Summary
Itamar Friedman argues that vibe coding becomes useful for enterprise development only when generated code is grounded in the team's codebase and software standards. Autocomplete helped developers write a few more lines, while chat-based agents can generate much larger amounts of code. That increase also creates more review work and can produce code that is difficult to maintain. Friedman wants AI across the software development life cycle, including planning, implementation, testing, review, bug fixing, and refactoring. He presents workflows and specialized agents as the way to connect these tasks. Qodo's approach combines agents for code research, review, coverage, and development-time guidance. The command line is central because it lets developers run agents in pipelines, call specialized agents, pass logs and results around, and eventually connect agents through A2A. His final model is a swarm of agents with different tools, credentials, and organizational practices.
AI development is moving through autocomplete, chat, and command-line workflows
Friedman describes three stages of AI-assisted development. Gen 1 was autocomplete, which helped developers generate a few lines ahead but assumed they already knew how to code. Gen 2 was agentic chat, which let even junior developers generate much more code. Enterprise developers could use it, but they also had to review more code and often found its quality lacking. The next stage is command-line interaction, where developers give commands to agents as if they were team members. Those agents can handle an end-to-end flow instead of only completing a local coding task.
Enterprise development needs AI across the whole software life cycle
Friedman separates simple software generation from heavy-duty enterprise work. Vibe coding often focuses on planning and writing an initial implementation, but developers also fix bugs, refactor code, change features, test, and review. They need to move quickly without breaking existing behavior. He says testing and review should act more like a red team or technical lead, rather than being an afterthought inside a development tool. AI must cover these separate tasks and connect them through workflows. The intended result is code that follows company practices before a later review tool reports problems.
Confidence comes from context and workflows around code generation
Friedman responds to criticism that AI coding tools are less useful on large existing codebases than on greenfield projects. A simple new application may need little more than code generation, while an enterprise system also needs maintainability, testing, and review. He points to the need for the right context and a workflow that uses it. Manual context gathering can help, but he says it is not enough if developers have to assemble everything themselves. Workflows can connect agents, incorporate organizational practices, and apply quality checks as code is created.
Agents can compress planning, coding, testing, and review into connected work
Friedman maps planning, code writing, testing, and review across time and executability. Planning is not executable. Implementation is executable, while tests are executable but are not application code. He describes the desired change as squeezing these stages together through agents and workflows that communicate. MCP and A2A are part of this model. Different agents might talk to one another, or one agent might use tools that connect the stages. The goal is a holistic software development flow that examines the work across these steps rather than treating each activity as an isolated tool.
Qodo combines specialized agents with accumulated code knowledge
Friedman describes Qodo's multi-agent architecture. One agent handles deep research and questions about code. Qodo Merge focuses on code review. Development-time tools bring context and collected best practices into the coding environment. He says Qodo Merge accumulates organizational best practices over time, while Qodo's context system supplies relevant codebase information. These pieces can guide whichever code generation tool a team uses. Qodo also has an open-source coverage tool that automatically increases coverage, and the coverage capability is available through an agent.
Friedman argues that the command line fits agent-based development because developers can run tools in the background, create workflows, save logs, and pipe tools together. In his example, a code-generating agent is followed by a coverage agent that adds tests, then a review agent. The pipeline passes results from one stage to the next, although he distinguishes this from direct agent-to-agent communication. He says A2A could let several agents run in parallel and communicate through discovery and handshakes. This matters when a system has many specialized agents.
Generated agents can carry instructions, tools, schemas, and quality criteria
In the demonstration, Friedman asks Qodo's agent to create a review agent. The generated definition includes the agent's instructions, the tools it can use, and an output schema. The new agent also receives parameters that let the developer specify what to review. Friedman says developers can give it organizational best practices and success or failure criteria. Coverage is one example of a criterion that can tell the workflow whether the work succeeded. These agents can also be connected to pre-commit and post-commit actions so that the workflow runs automatically.
A future development interface can be generated for each task
Friedman says the command line does not have to be the only interface. He points to a demonstration where a CLI was used to start work, while other interfaces were used to inspect content. His proposal is that the CLI can generate interfaces suited to the task, such as a dedicated code-review interface. This makes the traditional IDE less central because developers can choose or create an interface around the workflow they need. He closes with a model of specialized agents that have different credentials, tools, and organizational best practices.
"The next aha moment was you know all the hype around vibe coding and I'm going to touch about that and I think the next like thing that I think we're going to hear about is like hey I'm really doing 100x choose choose a number 10x 50x 100x development and I'm doing that with confidence not just like vibing through it."04:36
Who should watch
You are building or maintaining a large existing codebase and chat-based code generation creates too much review work.
Your team wants to connect planning, implementation, testing, coverage, and code review into repeatable agent workflows.
You are evaluating command-line agent tools, MCP, or A2A and want an example of how they could fit into development practice.
