Quick Reads (Under 5 Minutes)

Here’s what I’m coding full time on (when I’m not consulting with clients). A GraphRAG to support Legacy .NET modernization:

Code — particularly in strongly typed, compilable languages — forms a natural network structure. We analyze those relationships in C# or VB app and SQL database code, store them in a database as knowledge graphs, then use graph queries to trace dependencies or similarity search to identify patterns. Agent responses get this context via Model Context Protocol (MCP).

All this to provide better context and more precise agent responses for analysts, architects, and engineers looking to understand, communicate, and rewrite their legacy .NET applications.

People can embrace the societal benefits of AI-assisted software, earn compensation using these tools, insist on human accountability and the primacy of human expertise. All the while remaining skeptical of over-promises, wary of unethical practices, and advocates against harm.

One sign your refactoring is improving your domain model is when you find your linter flagging a whole bunch of now unused namespace import statements after the changes.

With Code Generation, an accurate Domain Model and naming scheme are even more important. If you think humans get confused by namespace, object and method names that don’t accurately describe what they do, try dealing with the wrong paths an AI agent veers towards because of them.

I used this coding prompt to build out a new implementation to an existing interface. It worked well, creating a “chose your own adventure” experience where the coding agent frequently stopped to ask me which direction to take (whether to patch the class or change the test expectation or which of two approaches to take to a change or whether to insert more diagnostic console writes).

“You can run the @ScoredOutputNodeTree.cs and use the failures to drive changes into @ScoredOutputNodeTree.cs . You are only allowed to make changes to those two files. After any change run the entire fixture to ensure the net number of red tests decreases. If you have any issues with the edit tool, want to make changes beyond the scope of those two files, or are creating regressions stop and let me know how I can help.

When existing tools can handle part of a task - use the tools. Employ generative AI to fill practical gaps in existing tools where its capabilities are worth the unpredictability. Do so with clear guardrails and human oversight. Keep expert humans responsible for how the work is performed and accountable for the outcome.

I’ve worked with technical people who are both exceptionally capable and generous givers. Through their own performance and actions towards others they help co-workers improve their own craft and instill a drive to push for practices and conditions that enable teams to flourish.

To summarize what’s clicked for me this week working with a code gen IA. A good set of instructions likely includes:

Incremental Verification - using tests to coerce the agent to make smaller changes and verify before making additional changes - whether truly test first or test after.

Explicit boundaries - what files can the agent change and what files should it not change in order to implement the feature. Prohibit unmanaged changes files that might introduce regressions. The agent will stop and describe what it wants to do (Very powerful).

Stop conditions - Conditions under which an agent should stop attempting to make changes and ask for help, i.e. the edit tool has misapplied a change and altered the code files in ways the agent didn’t intend, it introduces a regression in the test suite, etc.

If you have other types of guards you add to your instructions, please let me know.

Over reliance and unsupervised use of agentic AI creates waste and quality issues:

Here’s a small example: I need to change a method signature of an interface and all implementations and tests accordingly.

• A refactoring tool uses static analysis to identify the dependencies and make the changes pretty instantaneously — Fast, comprehensive, and marks areas of code that need additional changes.

• A code gen agent, changes the interface, searches for places that might require a change, compiles, finds errors, fixes them, repeat, repeat. Each prompt/response racks up increasingly more expensive compute costs. In each iteration the agent can go off on a tangent and make other changes while its there, planting hidden defects.

What are you doing to use the tools appropriately, retain your control over outcomes while benefiting from the speed gain?

Large language models reward two behaviors that don’t translate well to humans: micro management and direct feedback bordering on incivility. This does not vindicate leading people this way. A machine doesn’t leave a working session better or worse for spending time with you. People do.