Q&A

Claude Code for .NET Developers: Agentic Coding in the Enterprise

• By David Ramel
• 09/10/2026

AI-assisted development is rapidly moving beyond autocomplete. While tools that suggest the next line or block of code remain part of everyday developer workflows, a newer generation of coding agents can take on broader tasks: exploring repositories, editing multiple files, running commands, testing changes and iterating toward a result.

Anthropic describes Claude Code as an agentic coding tool that can read a codebase, edit files, run commands and integrate with development tooling. Its agentic loop centers on gathering context, taking action and verifying results, with developers able to intervene and redirect the work along the way.

That makes the comparison with GitHub Copilot more interesting than a simple agent-versus-autocomplete matchup. GitHub still offers the familiar inline suggestions that appear while developers type, but it also offers agentic capabilities. In Copilot's agent mode, for example, the tool can determine which files need changes, suggest terminal commands and iterate through a multi-step task.

For .NET developers, those evolving capabilities are especially relevant to applications built with ASP.NET Core, Microsoft's cross-platform, open-source framework for modern web apps and services. Enterprise projects can span APIs, web frontends, cloud infrastructure, mobile clients and years -- sometimes decades -- of accumulated business logic. An agent that can navigate those boundaries potentially changes not only how quickly code gets written, but how developers investigate, migrate and maintain existing systems.

That's the territory Mark Perry, Principal Consultant at Pulse AI Solutions, will explore in the intermediate-level Claude Code for .NET Developers: Agentic Coding in the Enterprise session at Live! 360 Tech Con in Orlando.

Mark has spent 25 years building enterprise applications, and he says Claude Code has changed his working habits more substantially than any other development tool in that span. One striking example is parallelism: he now keeps four terminals open while working across four different projects at the same time, a workflow he says would not have been practical for him before.

His Nov. 18 presentation will focus on what he learned while getting to that point, including the mistakes and "gotchas" that came with adopting agentic development. Rather than pitching a single tool as the answer to every coding task, Mark plans to demonstrate production workflows, compare Claude Code with Copilot and explain where he finds each approach most useful.

That distinction is partly about how developers choose to divide the work. Mark characterizes Copilot in his own workflow as particularly useful for inline, reactive assistance, while Claude Code is something he can hand a larger task to and then review. His experience also highlights a broader change in developer responsibilities: as the agent takes on more implementation work, the human developer spends more time specifying requirements, steering decisions, testing results and reviewing the resulting code.

Some of Mark's most valuable use cases don't involve generating new code at all. He has used Claude Code to investigate unfamiliar legacy code during migrations, including tracing complicated business calculations in older applications and comparing them with new ASP.NET Core implementations. In enterprise development, where preserving decades-old business rules can be more difficult than creating a new endpoint or UI, that ability to interrogate and reconcile existing systems can be significant.

The session will also address how to get better results from prompts. Mark's favorite technique is deceptively simple: before asking Claude Code to build something, he describes the goal and asks the agent to pose five questions about what he's about to build. The resulting questions can reveal unstated assumptions, edge cases and constraints before implementation begins.

Just as important are the controls around agentic coding. Mark recommends working from backed-up repositories and branches, keeping tasks tightly scoped, testing applications personally and reading the generated code. He also advocates recurring code and security reviews across an entire repository -- while emphasizing that the developer remains responsible for reviewing what the agent produces.

We caught up with Mark to discuss how Claude Code has changed his .NET workflow, where it has proven most useful in enterprise applications, how he compares it with Copilot and what developers should do before handing substantial work to a coding agent.

PureAI: What Inspired You to Present on This Topic?
Mark: I've been a software engineer for 25 years, mostly building enterprise applications. Claude Code changed how I work more than any tool in that span -- not just my speed, but how I think about building things.

The clearest example: I now run four terminals at once, working four different projects simultaneously. That wasn't possible before, and getting there taught me a lot. Most of it the hard way.

That's why I wanted to do this session. Not to sell anyone on the tool, but to show the gotchas I hit on the way to actually being more efficient with it.

What Does Claude Code's Terminal-Based Approach Let .NET Developers Do Differently from an IDE-Based Assistant?
Claude Code writes the code. You've gone from rowing the boat to steering it.

Your role shifts to tester and reviewer instead of typist. And you're still in control -- if you don't like how it implemented a function, you tell it to do it differently, or the way you'd have done it yourself. It's a conversation, not a one-shot generation.

The practical consequence for .NET developers: your IDE becomes the place you run and test the app, not the place you write it. That's a real adjustment, and it's the part people underestimate.

Which ASP.NET Core Development Task Have You Found Claude Code Particularly Effective at Handling?
A few, but the one that surprised me most isn't writing code at all -- it's understanding old code.

If there's a bug, or a function nobody on the team can explain anymore, Claude Code will walk you through what it does and how it reached that conclusion. That's a different kind of value than generation, and on enterprise applications it's often the harder problem.

I've leaned on that heavily during migrations. Moving an old ASP.NET application to ASP.NET Core with a React frontend, I could point it at the classic ASP repo and ask how a complicated financial calculation was handled in the original, then compare that against the new implementation. It reads both versions and reconciles them for you. When you're migrating decades-old business logic, that's the part that actually keeps you up at night, and it's exactly where I've gotten the most out of it.

Beyond that, it's been effective with Blazor -- I've built several applications on it -- and it handles .NET MAUI well, which I didn't expect given how much is going on in a MAUI project.

What Prompting Technique Most Improves the Quality of Code Claude Code Generates?
Before I let it build anything, I describe what I want and then say: "Ask me five questions about what I'm about to build."

I know what I'm building. Claude doesn't. Those five questions surface the assumptions I didn't realize I was making -- the edge cases, the constraints I skipped over. Answering them refines the prompt before a single line gets written.

It costs thirty seconds and it's the single biggest quality difference I've found.

How Do You Give Claude Code Enough Repository Context Without Overwhelming It?
Honestly, I've never hit that wall.

It reads the full repo, and it handles more than one. In a single terminal I can have it working on an ASP.NET Core API with a React frontend, plus the Android app that talks to that backend, plus the iOS app. It moves between them without confusion.

If it does start feeling off -- answers getting vague, losing the thread -- clear the context and keep going, or move up to a stronger model. That's usually all it takes.

What Is One Common Mistake Developers Make When First Using Claude Code on an Existing Enterprise Application?
Two, and they're both about scope control.

First: make sure the code is backed up and work in branches. On an older application especially, point it at a fresh repo rather than the one you can't afford to break. Cheap insurance.

Second: break the work into chunks. Don't say "fix my million-line application." Give it a defined piece of work with a clear boundary. Scope is the difference between an agent that's useful and one that's unpredictable.

When Would You Choose GitHub Copilot Instead of Claude Code?
Two situations, and neither is really a competition.

Documentation. Copilot is good at it, and it's the kind of task where inline suggestions in the editor fit the work better than delegating to an agent.

And practically: when I hit my usage limits on Claude Code, Copilot is what I switch to so I'm not sitting idle. That's not a knock on either tool -- it's just how a working day goes when you're leaning on AI this heavily.

The bigger point is that these aren't mutually exclusive. Copilot is inline and reactive, completing the line you're writing. Claude Code is a task you hand off and review. I use both, and I think most developers should. The session goes deeper on where each one wins.

What Review or Testing Step Should Developers Never Skip After Claude Code Makes an Agentic Change?
Test the app yourself, and read the code.

The temptation runs the other direction -- as you get comfortable with the output quality, it gets easy to tell yourself the review is optional. That's exactly when you should keep doing it. Reviewing the diff is the part I don't delegate.

The other thing I'd recommend, which most teams have never done: schedule a recurring full-repo review. I have Claude Code run a complete security audit and code review across the repo weekly -- Friday afternoon or over the weekend. It's a small ask for the tool and you'd be surprised what it surfaces, including in code it wrote itself.

That kind of standing audit just wasn't practical before. Now it costs you almost nothing.

How Can Attendees Learn More About This Topic, and Prepare for Your Session?
Get Claude Code installed before you show up. Two paths on Windows:

Working primarily in the Microsoft stack -- PowerShell
Working with React or Node tooling -- WSL

Then start building. Pick something you actually care about and use it. Reading about this doesn't teach you much; twenty minutes on a real project teaches you a lot. Come to the session with questions from your own code and you'll get more out of it.

Mark Perry is Principal Consultant at Pulse AI Solutions (pulseaisolutions.com), where he builds AI-powered applications on .NET and Azure

Note: Those wishing to attend the session can save money by registering early, according to the event's pricing page. "Save $400 by registering by the Super Early Bird deadline of Sept. 25," said the organizer of the event, which is presented by the parent company of Pure AI.