Back to notes

Why I Build With AI Agents (Not Just AI)

AIDevelopmentProductivity

Release context: the integration example below describes earlier AVAROS planning. The current v0.1.1 release excludes DocuBoT and treats PREVENTION as optional; see the updated case study.

There's a meaningful difference between using AI to write code and building an agentic development workflow where AI agents collaborate with you as a system. I've been doing the latter for the past year across EU R&D projects, and the distinction matters.

AI-Assisted vs. AI-Augmented Development

Most developers use AI as a smarter autocomplete. Ask a question, get an answer, copy-paste it in. That works, but it leaves enormous potential on the table.

What I mean by agentic development is:

  1. Custom VS Code agents with domain-specific instructions (e.g., an agent that understands Docker-Compose orchestration for IoT stacks)
  2. Multi-step workflows where agents propose architecture, generate scaffold code, and review their own output
  3. Human-in-the-loop validation at every meaningful decision point — I never deploy agent output without review

This isn't about replacing engineering judgment. It's about amplifying it.

A Concrete Example

On the AVAROS project, I needed to integrate four independent subsystems (OVOS, DocuBoT, PREVENTION, RENERYO) into a single Docker-Compose deployment. Each had its own API contracts, health checks, and volume requirements.

Instead of manually writing all the integration code:

  1. I described the system architecture to a custom agent with context about each subsystem
  2. The agent proposed API contract interfaces and Docker-Compose service definitions
  3. I reviewed, corrected assumptions about network topology, and refined
  4. The agent generated integration tests based on the corrected contracts
  5. I ran the tests, fixed edge cases, and shipped

The useful change was the feedback loop: the agent could propose an interface quickly, while I checked the assumptions against the actual deployment. The work still depended on engineering review, integration tests, and deliberate ownership of the result.

The Orchestration Mindset

The shift is from "developer who uses AI tools" to "developer who orchestrates AI agents." The key principles:

  • Context is everything — agents perform dramatically better with project-specific instructions and constraints
  • Validate, don't trust — every agent output gets human review before it matters
  • Compound workflows — chain multiple agents together, each with a specific role (architect, implementer, reviewer)
  • Know when NOT to use agents — some tasks are faster done manually; recognize the crossover point

What This Means for My Work

Agentic workflows are part of my engineering practice. I use them where a clear task, enough context, and a meaningful validation loop make the result useful.

If you're evaluating my work: the code quality, architecture decisions, and documentation you see are mine. The agents accelerated the path to get there.

Want to discuss agentic development workflows for your team? Get in touch.