Coding with Agentic Tools
Coding with agentic tools means partnering with an AI agent through iterative workflows where you provide direction, the agent executes, and you review at checkpoints.
Think of it as pair programming: you guide the intent, the agent handles implementation, but don't outsource your thinking.
Workflow patterns
Choose your approach based on task complexity and familiarity:
| Pattern | When to Use | How to Use |
|---|---|---|
| Implement → Review | Simple, well-defined tasks with clear solution | Ask agent to code, review result, iterate if needed |
| Plan → Review → Implement | Medium complexity, need alignment before coding | Agent creates plan, you review/adjust, agent implements |
| Divide et Impera | Large or medium tasks that can be decomposed | Break the task into smaller chunks yourself, then apply one of the other strategies to each chunk |
| Research → Plan → Implement | Unfamiliar codebase or unclear approach | Agent explores codebase, plans approach, then implements |
| Spec → Plan → Review → Implement | Complex changes requiring precise requirements | You write spec, agent plans, you review, agent implements |
| Test → Implement → Validate | TDD approach, clear requirements with testable outcomes | Write/spec tests first, agent implements to pass tests, validate results |
Reviewing agent code
What are you reviewing for
| Priority Level | What to Check |
|---|---|
| Mental Alignment | The team is able to understand how the changes evolves the system all of you are working on |
| Correct Solution | Ensures the change correctly solves the problem |
| Design Discussion | • Clear separation of concerns (should this part be in utils or validation service?) • Domain boundaries are well-kept (service layer vs controller layer, correct feature folder?) • Performance implications • Data contracts (DTOs) • Data flow correctness |
| Find Bugs | Ensure no edge cases are present |
| Style | The code is written in the 'good way' (best practices, self-explanatory code) |
How to review AI code
Follow the hierarchy from most to least important:
- Mental Alignment (for you): Review the plan first—is the intent behind the changes correct? Can your team understand the approach?
- Correct Solution: Test the solution → does it work? If not, the AI still has work to do. Add a way for the agent to validate its own work: give it eyes (tests, access to browser, screenshots, etc.)
- Design Discussion: Check separation of concerns, domain boundaries, performance implications, and data contracts. You can ask the agent to code review (with a separate context window) for problems following these principles
- Find Bugs: Look for edge cases, null checks, error handling, and boundary conditions. You can use the agent to brainstorm possible problems
- Style: Verify the code follows project patterns and is self-explanatory
- Mental Alignment (for others): Give your team context in a Code-Review regarding a change, offer concise and simple-to-understand information regarding the change as a summary.
Key principle: Stop at the lowest failing level. Don't review style if the solution doesn't work.