"Agentic" is on every profile this year, usually with nothing behind it. So instead of a claim, this post is a case file. Agentic development, as I practise it, means four things: I build products where AI agents do real work, I build the tools agents use, I run teams of coding agents to ship software, and I measure all of it so the results hold up. Each section below links to the write-up, the numbers and, where I can share it, the working thing.

#1. What I Mean by "Agentic Developer"

Prompting a chatbot isn't it, and neither is accepting autocomplete suggestions. An agentic developer works at three levels:

  • Product: designs systems in which a model plans, calls tools and takes actions, with guardrails around what it's allowed to do.
  • Tooling: gives agents the context they lack: memory, access to real systems through MCP, and conventions packaged as skills.
  • Process: delivers software with several agents working in parallel, assigned roles, reviewed by other agents and by a person, and merged only with proof.

The test for each level is simple: is there something running, and is there a number?

#2. Evidence: I Build Agentic Products

#A multi-tenant AI agent platform on .NET 10

An embeddable assistant built on Microsoft Agent Framework: agents with MCP tools for database and document access, pgvector retrieval, text-to-SQL, guardrails for personal data, and streaming answers. It worked, but a data question took 30 to 40 seconds. I audited the whole request path, ranked the fixes, and moved the agent to Agent Framework. Most answers now arrive in about 13 seconds.

#Choosing the hardware an agent runs on

For a self-hosted agent, I benchmarked an RTX 5090 against an NVIDIA DGX Spark with the same model, the same Ollama version and the same request. The 5090 answered in about 15 seconds and the Spark in about 41. Memory bandwidth, not memory size, decided it. Running agents on your own servers means making calls like this from measurements, not spec sheets.

#An AI email assistant that can't act on its own

An on-premises assistant that classifies client email with a local model, assigns owners and deadlines, and drafts replies. The agentic part is as much about what the model can't do: it never sends, closes or reassigns anything, and instructions inside an email are treated as text. The classifier is measured on an evaluation set: from 26/35 to 41/43, with average time down from 43 seconds (with timeouts) to about 4.

#Retrieval that agents depend on

Agents are only as good as what they retrieve. I built hybrid product search on Solr 9, fusing BM25 and vector results with Reciprocal Rank Fusion, and a RAG pipeline for developer documentation.

#3. Evidence: I Build the Tools Agents Use

#An MCP server that maps a codebase

Coding assistants are good with the file you have open and poor at "who calls this stored procedure?" across a 40-project solution. I built a Model Context Protocol server that analyses C# solutions with Roslyn and SQL Server schemas through catalogue views, and exposes the results as more than 40 tools. Agents answer those questions from facts instead of guesses.

#This site is agent-readable

The portfolio you're reading has its own MCP endpoint, so any MCP client can search my projects and posts, plus llms.txt and llms-full.txt for models that read the web.

#Memory, reach and habits

My day-to-day setup gives every agent three things: an Obsidian vault as memory (decisions, runbooks, incidents), MCP servers as reach into real systems, and Skills as habits, so house style is applied every time rather than when someone remembers it.

#4. Evidence: I Run Teams of Coding Agents

#A standing agent team in Herdr

Claude Code is the tech lead: it researches, finds the bug, discusses it with me, and delegates. Five Antigravity sessions are the developers, each owning one area of the codebase. GitHub Copilot CLI reviews everything first, and Codex gives the risky changes a second review. A standby agent takes over as lead when Claude hits its usage limit. They hand work to each other through Herdr's hc send, and the whole team is defined in one file.

#Spec-driven delivery with four agents

For the email assistant, a plan of about 260 person-days became a working foundation in two days and 110 commits: sign-in, roles, tenant separation, mailbox sync, AI classification and work items. That took a written spec with numbered requirements, a shared rule book, ownership per agent, a git worktree per task, and a lead that reviewed, built and tested before every merge.

#Skill files that turn a sprint into two days

A group of legacy background services moved to cross-platform .NET 10 worker services in two days. The agent didn't make that fast on its own: two stacked skills (a house style and a migration playbook) told it what "done" looks like, ending in a checklist that doubled as the reviewer's map.

#This site, built the same way

This portfolio is a Next.js 16 front end and a .NET API with passkeys, an admin, content sync, live presence and a status page. Of its 166 commits, 105 were written with an AI agent and carry its co-author line. Every one was reviewed and merged by me.

#5. Evidence: I Measure, and People Stay in Charge

The difference between agentic and reckless is proof. A few habits I hold to:

  • Evals for AI behaviour. Prompt and model changes run against a fixed evaluation set before and after. That's how the email classifier went from 26/35 to 41/43, and how we found that less thinking was both faster and more accurate.
  • Measurements for performance. When this site scored poorly on mobile, Lighthouse showed 25 seconds of blocking time. One "optimisation" an assistant proposed made it worse, and only a measurement caught it. The details are in the workflow post.
  • Load tests before release. Repeatable k6 and Grafana suites catch latency regressions before code reaches staging.
  • Review by a different model, then by me. Reviewers get checked too: one of Copilot's findings described a scenario that couldn't happen.
  • Git and decisions stay human. Agents propose, implement and report. Nothing is assigned until I agree, nothing merges until it's proven, and agents never commit or push.
What agentic is not

It isn't "the AI wrote it, ship it". In every project above, agents did the repetitive work and a person owned the judgement: what to build, what counts as done, and what's safe to merge.

#6. The Short Version

ClaimProofNumber
Builds agentic productsAgent platform audit30–40 s → ~13 s
Runs agents on own hardware5090 vs DGX Spark~15 s vs ~41 s
Measures AI behaviourEmail classifier evals26/35 → 41/43
Builds tools for agentsCode-intelligence MCP server40+ tools
Leads agent teamsHerdr team9 agent sessions
Delivers with agentsEmail assistant foundation~260 PD plan → 2 days
Encodes conventions as skills.NET 10 migration2 days
Dogfoods itThis site105 of 166 commits with an agent

#7. What This Means for Your Team

If you're bringing coding agents into a real codebase, the hard part isn't installing them. It's the spec they build against, the rules they can't break, the skills that carry your conventions, the review that catches what they miss, and the evals that tell you whether the AI got better or just different. That's the work I do. I'm happy to talk through how it would fit your team: work with me.