FOR .NET TEAMS | WORKSHOP, TECHNICAL PILOT AND GUIDANCE

Agentic coding for .NET teams

AI-native software development: agents do the execution, your developers decide and review.

Your team uses AI tools. I help developers apply AI agents in your own codebase: concrete tasks, with attention to specifications, context, tests and targeted review.

Through a hands-on workshop, a scoped technical pilot or targeted guidance.

Sound familiar?

Your developers are experimenting with GitHub Copilot, Claude Code, Codex and Cursor. But the output stays the same, only the tooling changed. The backlog grows, velocity doesn't. AI generates more code, so PRs get bigger and review pressure rises with them. The potential is there; the way of working just hasn't caught up yet.

You want to see it work in your own code, on a concrete task, with someone who does this every day.

What is agentic coding?

Agentic coding is software development where AI agents take on whole tasks in your codebase: changing code, running tests, refactoring and processing feedback. A developer's work shifts from typing to specifying, reviewing and steering. This way of building is increasingly called AI-native software development. Agentic coding is the technique within it.

What you can gain is shorter lead times: less waiting, more parallel tasks, faster iterations. That takes a way of working around it: sharp specifications, good context, tests and targeted review. Without it you get 32 review rounds on a single PR and growing verification debt (articles in Dutch).

OFFERING

Second opinion, workshop or technical pilot

Already have a plan or a way of working?

Second opinion

An outside view on your way of working or your plan: two working days (16 hours), with one day on site and written advice. No cure, no pay: if it brings you no new insights, you pay nothing.

Two working days, fixed price

See the second opinion

Or get to work straight away. Two ways to start, each with scope and deliverables agreed up front. The size is set per engagement.

Hands-on workshop

For a concrete technical question. For example: how do we use agents for tests, a refactor or a migration in our codebase?

  • Goal: afterwards everyone can do more with agents than before, including those already further along, and has seen what is possible in your own code.
  • Beforehand: every participant fills in a questionnaire, so we start at the right level.
  • What we do: developers work with agents themselves on an agreed task, with explanation of specifications, context and targeted review.
  • Deliverable, for example: a worked example in your own code, with the instructions and prompts used.
  • Needed: a preparatory conversation, access to the tooling and a suitable task or repository.

Technical pilot

For the question whether and how agentic coding works for a specific challenge or way of working in your existing codebase.

  • What we do: pick a fitting first use case, sharpen specifications and acceptance criteria, set up repository context and agent instructions, and assess the result together.
  • Deliverable, for example: a worked-out approach for that challenge or way of working, with the matching instructions, tests and documentation.
  • Needed: access to the repository and the tooling, and one or more developers who take part.

Follow-up guidance

After a workshop or pilot, targeted guidance can follow, within an explicitly agreed scope.

  • What that can be: looking along on a new use case, discussing technical decisions or building along on a scoped part.
  • Not an automatic step: after the evaluation we decide together whether a follow-up makes sense.

Checks that fit the risk. AI fills missing specs with assumptions. So review starts at the specification and the design, automated checks and agent review handle the routine work, and a human reviews the crucial decisions and risky changes. Up front we agree on what counts as enough evidence to move on. I help set up those checks; the team stays the owner of the code.

What a pilot can deliver

  • A worked-out approach for one agreed challenge or way of working, for example writing tests, a refactor or PR preparation
  • Repository instructions that fit your conventions, rather than a generic template
  • Relevant tests and verification steps, with agreements on what counts as enough evidence to move on
  • Documentation of the technical decisions and of the limitations we ran into
  • A substantive handover session with explanation and practice, aimed at developers being able to continue on their own

These are examples. What a workshop or pilot delivers is agreed up front. A prototype or a configured way of working is not yet a production-ready feature; we record that distinction as well.

From daily practice

Where do I get this knowledge? I build Invullen.nl entirely with Claude Code and maintain Factuur-Assist.nl (135+ customers) with it daily. So I also know the mess around the demos: failing tests, oversized diffs, odd assumptions and context that isn't applied. 20+ years in .NET at ABN AMRO, PGGM and Van Lanschot among others. Microsoft Certified: Azure AI Apps & Agents (AI-103) and Identity & Access (SC-300). A concrete example: I migrated the front-end of a legacy part of Factuur-Assist with agentic coding in 5 days. By my own estimate I would previously have set aside around 20 days for it.

Honest about where this stands. I apply agentic coding on my own SaaS every day. As a service for other teams it's newer. That's why I work with a scoped workshop or pilot: one concrete question, one codebase and deliverables agreed up front. Afterwards we evaluate together what it delivered and whether a follow-up makes sense.

More about me

FOR YOUR LEAD OR MANAGER

Proposing this to your team?

In short: I help your developers apply AI agents in your own codebase, through a hands-on workshop or a scoped technical pilot. What we aim for: using agents deliberately for implementation, tests and analysis, with checks that fit the risk. What that delivers in your situation is something we assess together at the end. My contribution is technical and subject-matter. The client takes care of priorities, available participants and organisational decisions.

The deal in short

  • Format: a workshop or a technical pilot. Time and duration are agreed per engagement.
  • Precondition: access to GitHub Copilot, Claude Code and/or Codex with a sufficient token budget (separate from my rate), and for a pilot access to the repository.
  • We discuss rate and scope in the 30-minute call.
  • Start: a 30-minute Zoom introduction, then a scoped proposal. See the offering.

Why this stays manageable

  • Daily practice: I build my own SaaS with agentic coding (Factuur-Assist, 135+ customers; Invullen.nl).
  • 20+ years .NET, Microsoft Certified (AI-103, SC-300).
  • Checks that fit the risk: automated where possible, human review where it matters.
  • Scoped: one concrete question, one codebase and deliverables agreed up front.
  • You take out the subscription with the AI provider yourselves. We check the data processing terms up front against the current documentation and your own policy.
  • Your team stays the owner of the process and the guardrails.

One line to forward

"This .NET specialist helps our developers apply AI agents in our own codebase, through a hands-on workshop or a scoped technical pilot. Scope, deliverables, tooling (Copilot/Claude Code/Codex) and rate you discuss in an introduction."

Frequently asked questions about agentic coding

What is agentic coding exactly?

Building software with AI agents that work autonomously in your codebase: generating code, running tests, refactoring. You specify, review and steer; the agent does the work. Tools like Claude Code, GitHub Copilot, Codex and Cursor make it possible. The difference with autocomplete is that the agent takes on whole tasks, not single lines.

What is AI-native software development?

A way of building software where AI agents do the execution and developers decide what gets built and whether it is good enough. Agentic coding is the technique within it: agents that take on whole tasks in your codebase on their own. In practice, AI-native development means your way of working is set up for it: specifications and context files as the steering, tests and targeted review as the safety net. That is how I build my own SaaS every day. It is about how you build software; AI inside your product is a different topic.

Is agentic coding safe enough for production?

That depends on the checks around it, not on the model alone. AI fills missing specs with assumptions. So review starts at the specification and the design, automated checks and agent review handle the routine work, and a human reviews the crucial decisions and risky changes. Tests or a second agent do not guarantee correctness, and neither does a human sign-off; together they reduce the risk. I help set up those checks and agree up front on what counts as enough evidence to move on. A good first step is often improving test coverage, partly with AI itself.

Does this only work with Claude Code?

No. I work daily with Claude Code, GitHub Copilot and Codex, and I also help with multi-provider setups. The approach is about the way of working, not one tool. Whichever AI provider your team uses, the principle stays the same.

How long does an engagement take?

We agree on that per engagement. A workshop is short and focused on one technical question. A technical pilot runs for an agreed period in your own codebase, with scope, preconditions and deliverables set up front. Afterwards we evaluate. Follow-up guidance is possible, but it is not an automatic next step.

What if my team resists AI?

I'm happy to discuss technical questions and concerns: about code quality, security, maintainability or what an agent can and cannot do well. Those concerns are often justified and help decide which checks we set up. Whether and how the team adopts AI remains a choice for the team and the organisation; my contribution is technical and subject-matter.

Have you done this with other teams already?

I apply agentic coding daily on my own SaaS. As a service for other teams it's newer. That's why I work with a scoped workshop or pilot, with scope and deliverables agreed up front, so you quickly see what it means for your codebase. What I have done for years: working inside teams as a senior .NET developer and architect at ABN AMRO, PGGM and Van Lanschot among others.

Can agentic coding run on our proprietary code?

Fair question, and usually the first one I get. The answer depends on the product and the plan you choose. Providers such as Anthropic, GitHub and OpenAI have their own terms for business plans on model training, data storage and data residency, and those change regularly. So we check them up front, together with your security team, against the current official documentation and your own policy; the outcome helps decide the tool choice. Which parts of the code an agent may and may not see is configured per tool. Your team takes out the subscription with the provider itself; I don't sit in between. My engagement runs through a standard contract for services. Working within security and compliance constraints is familiar ground for me from the financial world (ABN AMRO, PGGM, Van Lanschot).

Apply agents in your own codebase?

Let's get acquainted first. We explore your question, whether a workshop or pilot fits and whether I'm the right person for it. If it fits, you get a scoped proposal with scope and deliverables.

Prefer to email first? Send your questions, and tell me briefly what your team uses now: Copilot, Claude Code, Codex, Cursor or something else.