Coding With Agents in C#: Setup, Skills and Pitfalls in 2026

The Adoption-Trust Gap: Why Agentic Coding in C# Is Mainstream but Risky

Here's the paradox at the heart of agentic coding in 2026: 90% of professional developers now use AI coding agents at least weekly, and 68% use them daily, yet only 29% trust AI output to be accurate — down from 40% in 2024. Adoption and trust are moving in opposite directions, and for C# and .NET teams, that gap defines the real work.

The volume problem is easy to underestimate. Roughly a quarter of senior developers now generate more than 80% of their code with agents, and 37% of Codex users report they no longer write code without AI help at all. Your agents can produce more C# in an afternoon than your team reviewed in the previous month.

Speed without scrutiny has a price. A DryRun Security study found that 87% of AI-agent-generated pull requests contained at least one security vulnerability, with 143 security issues across just 30 PRs spanning Claude Code, OpenAI Codex, and Google Gemini. The same vulnerability classes kept recurring — broken access control, OAuth failures, missing WebSocket authentication, and rate limiting that was defined but never actually wired in.

The bottleneck has shifted from writing code to reviewing it. One engineer producing 7X the code of teammates consumed the review capacity of six people, according to Stack Overflow's reporting on decision fatigue. Easy AI-generated code strains every downstream stage — code review, DevOps, security, and infrastructure — and 66% of developers say their biggest frustration is AI solutions that are "almost right, but not quite."

What does this mean practically for a .NET shop?

• Security review belongs in the design phase, not after the code lands — specify authentication and rate-limiting requirements up front and verify the wiring explicitly.
• Write down which tasks agents can do alone and which need human approval; code that looks correct is not validated code.
• Measure cycle time and defects, not lines of code or token usage — generation speed is a vanity metric.
• Scale QA velocity alongside dev velocity, or the review queue becomes your new bottleneck.

The same trust problem extends beyond the agents themselves to the skills and instructions you feed them. Published research has found that roughly 26% of agent skills carry at least one vulnerability, which is why SkillzBench is building a free directory that security-scans, version-pins, and benchmarks every skill — including measuring the Lift each one actually delivers in a sandbox, with and without the skill, under identical conditions.

The sustainable model emerging across the industry treats agents as accelerators while keeping human review and accountability for production code. Seniority matters more, not less: experienced developers load more context, make smaller surgical changes, and reserve the most complex pieces for themselves. In C#, where type safety and runtime guarantees give you real guardrails, the teams winning with agents aren't the ones generating the most code — they're the ones reviewing it best.

What the Research Says About Where Agents Help — and Where They Fail

Adoption of AI coding agents is near-universal, yet the evidence on whether they actually make developers faster is far messier than vendor demos suggest. Two rigorous studies reach opposite conclusions, and the gap between them explains exactly where agents help and where they quietly cost you time.

According to a compilation of developer productivity research, a METR randomized controlled trial found experienced developers were 19% slower with AI tools while believing they were 20% faster — a perception gap, not a speedup. By contrast, Cui et al. measured 26.08% more completed tasks across 4,867 developers, and an early GitHub Copilot experiment recorded a 55.8% speedup on one well-defined task. The reconciliation is the task, not the tool: agents excel at well-defined, new code and struggle with complex changes in large codebases the developer already knows.

That distinction matters enormously for C# enterprise work, where much of the job is surgical modification inside mature .NET solutions with long-lived conventions.

Security failures are equally systematic. A DryRun Security study of Claude Code, OpenAI Codex, and Google Gemini found that 87% of AI-agent-generated pull requests contained at least one vulnerability, with 143 issues across 38 scans. The recurring classes are consistent rather than random:

• Broken access control and business logic failures
• OAuth failures and missing WebSocket authentication
• Rate limiting defined but never wired into the request pipeline
• Weak JWT secret management

As DryRun's CEO James Wickett puts it, security isn't part of agents' default thinking — these are design-phase gaps, not typos.

The downstream cost lands on reviewers. One engineer producing seven times the code of teammates consumed the review capacity of six people, and Smartsheet research found 80% of AI-generated content is edited before finalization. The bottleneck has moved from writing code to validating it.

This is precisely why per-task evidence beats headline benchmarks. Artificial Analysis warns that two agents with similar index scores can still differ sharply across repository reasoning, terminal workflows, and rubric-based evaluation. SkillzBench is building toward the same principle for agent skills: scanning, sandbox benchmarking with and without each skill, and publishing the resulting Lift so you can see measured impact instead of marketing claims.

Skills, proven.

A Practical Setup for C# Teams: Skills, Context and Governance Rules

The best C# teams don't ask agents to write more code — they ask them to write the right code, with the right context, inside the right guardrails. That distinction is what separates teams scaling agents successfully from teams drowning in review debt.

Start with how senior developers already work. Research on agentic coding found that experienced engineers load more context and make smaller, surgical changes on the most complex pieces of code, rather than asking for sweeping rewrites source. In a C# codebase, that means handing the agent your project conventions, relevant interfaces, and existing patterns before it touches anything. Rich context plus small changes produces diffs a human can actually validate — which matters when one engineer generating 7X the code of teammates consumed the review capacity of six people source.

Next, write the rules down. As one analysis puts it, "rules beat hype": document which tasks agents can do alone and which need human approval source. A typical split for a .NET team:

• Agent alone: unit tests for existing methods, doc comments, refactoring within a single class, dependency-bump PRs that build clean.
• Agent alone: boilerplate DTOs, mapping profiles, and internal tooling with no production data access.
• Human approval required: anything touching auth middleware, database migrations, payment logic, or public API contracts.
• Human approval required: any change to security configuration, secrets, or deployment pipelines.

Treat security review as a design-phase activity, not a post-coding step. A DryRun Security study found 87% of AI-agent-generated pull requests contained at least one vulnerability — including rate limiting that was defined but never wired in by any agent. Regex-based static analysis can't trace whether middleware is actually mounted or whether auth policies apply to every connection type, so specify your ASP.NET Core middleware wiring, JWT handling, and authorization requirements up front, then verify them explicitly.

Finally, package your conventions so any agent can follow them. Agent skills — SKILL.md instruction packages for tools like Claude Code, Codex, and Cursor — let you encode C# naming rules, testing patterns, and review checklists once and apply them everywhere. But vet skills before you deploy them: published research found roughly 26% of skills carry at least one vulnerability. SkillzBench is building a free, independent directory that pins every skill version, security-scans it, and benchmarks it in a sandbox to measure the Lift it actually delivers — so your team can browse, test, and equip skills with evidence rather than guesswork.

Measuring What Matters: Lift, Not Lines of Code

Your agent just generated 4,000 lines of C# in an afternoon. Impressive — and almost meaningless as a measure of progress. As commentators on agentic coding point out, metrics like lines of code and token usage — sometimes called "tokenmaxxing" — tell you how much the agent produced, not whether your team ships better software faster.

The productivity research itself is a caution against vanity metrics. A METR randomized controlled trial found experienced developers were 19% slower with AI tools while believing they were 20% faster. Meanwhile, other studies found 26% more completed tasks and a 55.8% speedup — but only on well-defined tasks. Perception and generation speed are not outcomes.

Measure cycle time and defects instead. How long does a task take from assignment to merged, reviewed code? How many security issues or bugs does the change introduce? These numbers survive contact with reality in a way token counts never will — especially given that 87% of AI-agent-generated pull requests contained at least one security vulnerability in one recent study.

The same evidence-first discipline applies to comparing agents and skills. Artificial Analysis's Coding Agent Index explicitly warns that two agents with similar index values can have very different strengths across repository tasks, terminal workflows, and rubric-based evaluations. An agent can excel at repository reasoning yet fail at reliable patch execution. A single composite score can mask exactly the weakness that will hurt your codebase.

That's why per-task evidence beats aggregate scores. When you evaluate an agent — or a skill you've attached to it — run it against a defined task with and without the augmentation, under identical conditions, and record the difference. A useful evaluation loop looks like this:

• Pick a representative task — a real bug fix, a feature slice, a refactoring — not a toy prompt.
• Run the same model with and without the agent configuration or skill, in a sandbox.
• Record the Lift in percentage points: pass rate with the skill minus pass rate without it.
• Track defects and security findings, not just completion.

This is precisely the model SkillzBench is building for agent skills: benchmarking every skill in a sandbox with the same model, with and without the skill, and publishing the Lift in percentage points — kept separate from trust scores and never influenced by money. It's the same standard you should apply in your own C# projects. A skill that claims to improve refactoring either measurably improves your pass rate on refactoring tasks, or it doesn't. Percentage points of Lift, on tasks that resemble your actual work, are the only endorsement worth trusting.

Your Action Plan: Equip, Validate and Stay Current

The evidence is clear: adoption has won, but trust hasn't. With 90% of professional developers using AI coding agents weekly, the question is no longer whether your team codes with agents — it's whether your process can catch what they miss.

Start with guardrails. Write down which tasks agents can do alone and which need human approval, and treat security review as a design-phase activity rather than a post-coding step. That matters because a DryRun Security study found 87% of AI-agent-generated pull requests contained at least one vulnerability, with recurring classes like broken access control and rate limiting that was defined but never wired in.

Then make validation non-negotiable:

• Run security validation on every AI-generated PR — not just the risky-looking ones.
• Scale QA with dev velocity; as Smartbear's Fitz Nowlan puts it, QA velocity must increase 10x alongside dev velocity.
• Measure cycle time and defects, not lines of code or token usage.
• Evaluate agents per task, since similar benchmark scores can mask very different strengths.

Finally, stay current. Upstream tools, models and skills change fast — Claude Code adoption alone climbed from 18% to 39% in a single year — so anything you validated six months ago deserves re-verification today. That's the problem SkillzBench is building for: a free, independent directory that dedupes agent skills from GitHub, pins every version to a commit SHA, security-scans, license-checks and quality-judges each one, plus a free MCP connector so your agents only see the skills you toggle on. Browse the directory and join the waitlist at skillzbench.com.