# Vibe Coding with Confidence

Itamar Friedman, Qodo | AI Engineer World's Fair 2025 | 20:55

Source: https://www.youtube.com/watch?v=n991Yxo1aOI
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/vibe-coding-with-confidence
Published: 2025-08-06
Tags: agents, coding-agents, multi-agent, testing, workflows

## TL;DR
- AI development is moving from autocomplete and chat toward command-line agents that can handle end-to-end software workflows.
- Enterprise code needs context, testing, review, maintainability, and company practices alongside code generation.
- 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.

## Key ideas
### AI development is moving through autocomplete, chat, and command-line workflows
[00:01](https://www.youtube.com/watch?v=n991Yxo1aOI&t=1s)
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
[03:50](https://www.youtube.com/watch?v=n991Yxo1aOI&t=230s)
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
[10:00](https://www.youtube.com/watch?v=n991Yxo1aOI&t=600s)
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
[08:32](https://www.youtube.com/watch?v=n991Yxo1aOI&t=512s)
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
[12:21](https://www.youtube.com/watch?v=n991Yxo1aOI&t=741s)
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.

### The command line makes agents composable
[13:55](https://www.youtube.com/watch?v=n991Yxo1aOI&t=835s)
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
[19:19](https://www.youtube.com/watch?v=n991Yxo1aOI&t=1159s)
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
[20:05](https://www.youtube.com/watch?v=n991Yxo1aOI&t=1205s)
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.

## Notable quotes
- "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)
- "You need to bring the right context and have workflows and these workflows can be connected to agent, could be part of the agent, could be part of your flows." (11:25)
- "Many here are developers. You can pipe tools together, agents you can pipe workflows." (17:00)
- "I think we're going into a future where we're going to have swarm of agents, each one specializing and having different credential, different best practices." (20:27)

## Tools & references mentioned
- Qodo
- CodiumAI
- MCP
- A2A
- Claude Code
- Qodo Merge
- Qodo Cover

## 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.

## Related talks

- [Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments](https://aietalks.com/talks/vibe-coding-at-scale-customizing-ai-assistants-for-enterprise-environments-i1upan6u) (Harald Kirshner, Microsoft, 15:26)
- [Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments](https://aietalks.com/talks/vibe-coding-at-scale-customizing-ai-assistants-for-enterprise-environments) (Harold, VS Code, 1:20:38)
- [From Vibe Coding To Vibe Engineering](https://aietalks.com/talks/from-vibe-coding-to-vibe-engineering) (Kitze, Sizzy, 25:28)
- [No Vibes Allowed: Solving Hard Problems in Complex Codebases](https://aietalks.com/talks/no-vibes-allowed-solving-hard-problems-in-complex-codebases) (Dex Horthy, HumanLayer, 20:31)
- [Vibe Engineering Effect Apps](https://aietalks.com/talks/vibe-engineering-effect-apps) (Michael Arnaldi, Effectful, 1:43:04)