Until 2023, coding was done by human developers with the help of Google search.
2023-2025: Humans crafted code and we had AI assisting.
2026 onwards: It would be agent crafted, human supervised & human directed.
This talk outlines a set of AI agents that needs to be deployed to build software that is production-ready and built under the watchful eyes of expert human engineers.
The legendary "10x developer"—the engineer who prolifically cranks out features, refactors critical data flows on the weekend, leverages split mechanical keyboards and mapped hotkeys to build entire components in seconds—once represented the pinnacle of individual efficiency.
Today, by deploying teams of AI agents, organizations can achieve 10x workflows, fundamentally changing how development is done. This talk is specifically grounded in front-end development a.k.a. React frontends.
I'm Ben, CTO at CodeWalnut. I delivered this talk at React Conference Goa, exploring AI's automation of the full development lifecycle: from requirements to production code, with expert human oversight.
Watch the full talk here; key excerpts below.
The Foundation: Rapid Context Building
The core challenge when using AI is ensuring the agent understands your unique codebase. Engineers should not waste time writing context that already lives inside your codebase, such as team best practices or codebase conventions. Instead, context is managed and delivered instantly via two primary structures:
1. Agent Skills: These are step-by-step instructions given to an agent to perform a specific task, such as applying specific TypeScript practices or using a standardized PR template when opening a pull request.
2. Knowledge Base: Ideally kept in a version-controlled file structure (like an .agents folder), the Knowledge Base contains the codified wisdom of your team. This includes definitions of component examples, testing best practices, naming conventions, and, critically, the Definition of Done and verification steps the agent must follow.
By tagging @BuilderAgent and giving it the unique context of the feature (e.g., fetching an active task from a Jira board), the agent spins up, assigns itself the role, and immediately starts building code following the rules defined in the Knowledge Base.
Transitioning to common pitfalls, let's explore why AI doesn't always deliver expected gains.
The AI Paradox: Why Development Velocity Stalls
While AI-assisted development (using tools like Cursor or Grok) has dramatically sped up code development, engineering leaders frequently find that overall team velocity hasn't increased proportionally.
The problem is the bottleneck of manual quality assurance (QA) and code reviews. Review processes can take hours at best. In most cases, they take days, including the wait time. Thus, delaying the final approval and subsequent merge of a pull request (PR).
Reviews often flag basic errors, like not following file naming conventions or not using existing utility functions—issues typical of a junior developer.
A senior developer taking the time to communicate this basic-level feedback doesn’t add significant engineering value.
To address this, we introduce automated solutions.
The Solution: Agent-Powered QA (The Second 10x Workflow)
To solve the QA bottleneck, a pipeline of specialized agents is introduced, effectively automating the entire review process before a senior developer even looks at the PR. This pipeline is often triggered using GitHub workflows that trigger advanced N8N workflows.
1. Verifier Agent: This agent’s job is simple: verify that the PR that Builder Agent built fulfills the requirements of the feature ticket set by the product manager or engineering manager. It looks at the PR diff and compares it against the requirements from the Linear issue or Jira task. If verification fails, it flags the issue back to the Builder Agent to intelligently iterate and fix the problem.
2. Tester Agent: When implementing features, developers sometimes fail to cover all edge cases or manually attempt to battle-test their own feature in the UI to battle-test the user experience. The Tester Agent focuses on ensuring strong test coverage, covering the full range of unit, integration, and most importantly, end-to-end tests. In an ideal setup, it can even check the deployed preview environment against the original Figma design to confirm UI element changes are intentional. The Tester Agent provides a "safety net" that guarantees the application continues to work as expected before pushing to production.
3. Reviewer Agent: Functioning like a senior developer, the Reviewer Agent reviews the code based on established team standards pulled from the team’s Knowledge Base. The goal is to fine-tune this model using the review comments and feedback of the team's best, most senior developers, achieving "true quality" outputs that are consistent and ensure adherence to codebase conventions. After the Reviewer Agent provides comments, the Builder Agent can be tagged to automatically iterate and incorporate the feedback.
With these agents in place, human roles evolve accordingly.
The Indispensable Role of Human Engineers
As AI handles routine and mid-level tasks, developers must ask: How do I grow and adapt to add lasting value to my organization?
Full automation doesn't sideline engineers; it frees them to focus on high-impact work: mastering advanced concepts, ensuring AI outputs production-quality code rather than "AI slop," and elevating software excellence.
To excel, engineers should adopt an architect's mindset, emphasizing:
- System Design Thinking: Mastering architectural patterns to guide AI effectively.
- Fundamental Principles: Enforcing SOLID, DRY, KISS, and Separation of Concerns in AI-generated code.
- Refactoring and Documentation: Eliminating technical debt and enhancing clarity, often overlooked priorities.
- Teaching and Mentoring: Leveraging code reviews to upskill mid-level developers in AI direction and context building.
FAQs
1. How can I ensure the AI agents follow my team’s specific coding conventions and best practices?
You must establish a Knowledge Base containing version-controlled files that outline your best practices, file naming conventions, UI libraries, state management usage, and Definition of Done. Additionally, you can create specific Agent Skills (step-by-step instructions) that the agent will always, or intelligently, apply.
2. What problem do AI agents solve that existing AI tools (like Grok or Cursor) do not?
Existing AI tools speed up individual development and ideation but often fail to accelerate the organizational process. AI agents solve the QA and review bottleneck by automating the verification, testing, and initial review stages, which typically consume hours or days of senior developer time.
3. What are the primary responsibilities of the specialized agents in the QA pipeline?
The Verifier Agent confirms the PR meets the original issue requirements. The Tester Agent writes and runs unit/E2E tests to ensure strong coverage and checks for UI discrepancies. The Reviewer Agent provides code comments based on senior-level review standards and team conventions.
4. If AI agents write and test the code, what should human engineers prioritize?
Engineers must shift focus to higher-level thinking: defining system architecture patterns, enforcing fundamental software principles (SOLID, DRY), performing necessary refactoring to remove technical debt, and improving overall documentation and the Knowledge Base.
5. What specific technology components are used to trigger and manage these automated workflows?
Tools like GitHub Workflows are used to trigger stages (e.g., activating when a PR is opened). N8N (or NM) workflows manage the sequence, fetching context (like roles, conventions, PR diffs) from the Knowledge Base and Linear issues, merging the data, and posting approval comments.
Analogy: Traditional software development is like a custom tailor shop, where the master tailor (senior engineer) tediously measures every button and seam (manual QA). AI workflows add automated machinery and specialized QA, handling bulk production and basics, freeing the tailor to architect codebases, set patterns, train apprentices, and uphold conceptual excellence.
When to Hire CodeWalnut?
