If I Did It - Confessions of What Could be a Killer A.I. Companion

GitHub Copilot inside Visual Studio should be terrifyingly good.

Think about the ingredients. Visual Studio already knows your solution, projects, references, symbols, dependencies, build configuration, compiler errors, tests, source control and debugging environment. Add an AI capable of reading code, reasoning across files, executing commands and writing software, and you should have something approaching an artificial developer sitting beside you.

Microsoft and GitHub have even introduced Agent Mode, which is supposed to move Copilot beyond question-and-answer chat. Agent Mode can determine which files need modification, make edits, invoke tools, run builds and tests, inspect failures and iterate.

That sounds remarkably close to what developers have been asking for.

And yet the experience can still feel like hiring a brilliant programmer, giving him amnesia, making him work through a mail slot, and requiring you to repeatedly hand him documents that are already sitting on his desk.

The tragedy isn't that Copilot is useless.

It's that you can see how incredibly useful it could be.

Visual Studio's GitHub Copilot Chat Disaster

Why Am I Explaining My Own Solution to My IDE?

One of the most frustrating problems is context.

Visual Studio already has the solution open. It already knows the projects. It already knows the classes, interfaces, dependencies, references, configuration files and directory structure.

Yet interacting with Copilot can still turn into an absurd exercise in telling the AI what it should already be capable of discovering.

• Look at this file.
• Now look at that file.
• No, the other file.
• This class calls that class.
• Remember the API client I showed you?
• No, not that one.
• Here's the file again.
• Asset referencing becomes a job in itself.

A genuinely useful AI development companion should examine the repository, construct a persistent understanding of its architecture and retrieve relevant pieces automatically.

The developer should explain the problem, not continually explain where the code lives.

Agent Mode: The Solution That Still Makes Me Manage the Agent

This is where Agent Mode is supposed to change everything.

Instead of explicitly telling Copilot which file to edit, Agent Mode is designed to reason about the task, search the codebase, determine which files matter, modify them, run commands and iterate.

Conceptually, this is exactly right.

The problem is that autonomy without dependable context, precision and transparency can simply create a new category of frustration.

A useful agent shouldn't merely have permission to wander around my repository.

It should understand it.

There is a huge difference.

If an agent repeatedly searches the repository to rediscover relationships it encountered earlier, that's not project knowledge. That's automated forgetfulness.

If I spend twenty minutes explaining how a subsystem works and tomorrow's interaction requires the same explanation, I don't have an engineering companion. I have an extremely intelligent contractor suffering from short-term memory loss.

Agent Mode should develop a durable semantic understanding of the repository: architecture, dependencies, conventions, important classes, tests, configuration, APIs and developer-defined rules.

Otherwise, we've merely automated the process of hunting for files.

Autonomous Doesn't Mean "Change Whatever You Want"

There is another problem with Agent Mode: granting an AI greater autonomy makes change discipline more important, not less.

If I ask:

"Fix the validation problem in this method."

I don't want an autonomous agent deciding that today would also be a wonderful opportunity to reorganize neighboring code, alter formatting, rewrite another method and remove something it believes is redundant.

The agent should operate under a software equivalent of the Hippocratic oath:

First, don't screw with unrelated code.

The default should be the smallest safe change capable of satisfying the request.

If Agent Mode discovers that broader architectural changes are advisable, fantastic.

Tell me:

Required change: 8 lines in ValidationService.cs

Optional improvement discovered: Authentication logic could be consolidated across three classes.

Then let me decide whether we're doing the second job.

Autonomy should eliminate busywork.

It should not eliminate developer control.

Welcome to Scrolling Hell

Then there is the chat window.

• Copilot generates an explanation.
• Then code.
• Then another explanation.
• Then proposed changes.
• Then more code.
• Then tool output.
• Then another response.

Agent Mode can make this even more ridiculous because now the AI may perform multiple operations while narrating its journey.

Pretty soon you're scrolling through an archaeological record of your afternoon.

Why?

I have an editor.

It is literally the primary purpose of Visual Studio.

Change the file.

Then show me something like:

Analyzed: 12 files
Modified: 3 files
Build: Passed
Tests: 47/47 passed
Warnings introduced: 0
Unrelated files changed: 0

That's useful.

• Let me expand any item when I want the details.
• Don't force every intermediate thought, code block and tool interaction into the primary interface.
• And at minimum, give us proper conversation navigation:
• Previous prompt.
• Next prompt.
• Previous agent action.
• Next agent action.
• Jump to file change.
• Jump to build failure.
• Jump to final answer.
• Collapse everything except prompts.
• Bookmark a response.
• Show only changes.

A modern IDE shouldn't require endless mouse-wheel archaeology to locate something the AI told me twenty minutes ago.

The Apply Nightmare

And then we arrive at one of the most dangerous words in AI-assisted development:

Apply.

For a small requested change, Copilot can sometimes behave as though it has been commissioned to rewrite the Magna Carta.

I ask for one modification.

• Why is the entire file changing?
• Why was formatting altered?
• Why did an unrelated method change?
• Why did a perfectly functional block of code disappear?
• Why am I now reviewing modifications to code that had absolutely nothing to do with my prompt?
• Agent Mode raises the stakes because the AI is increasingly capable of making changes across multiple files.
• That's useful when genuinely necessary.

It's terrifying when it isn't.

An agent should understand scope as a first-class concept.

Code unrelated to the requested task should be presumed protected unless modifying it is demonstrably necessary.

And if broader changes really are necessary, tell me why.

Death by Tab Key

The opposite experience can be just as maddening: microscopic acceptance.

• Accept.
• Tab.
• Accept.
• Tab.
• Accept.
• Tab.

At some point I'm no longer programming.

I'm playing the world's worst rhythm game.

Human review matters. AI-generated code should not blindly enter production systems.

But "human review" does not mean forcing a developer to approve every microscopic alteration individually.

Give me hierarchical review.

• Accept this line.
• Accept this block.
• Accept this method.
• Accept this file.
• Accept this task.
• Reject everything outside the requested scope.

And Agent Mode should give me another extremely important option:

Accept task changes, but reject opportunistic changes.

That single concept would eliminate an enormous amount of AI-generated code pollution.

You Broke It. Why Am I Telling You?

Perhaps the most absurd experience occurs when Copilot generates code containing a syntax or compilation error.

• Visual Studio knows there is an error.
• The compiler knows there is an error.
• IntelliSense knows there is an error.
• The Error List knows there is an error.
• And Copilot is sitting inside Visual Studio.

So why am I telling the AI what Visual Studio already knows?

This is actually where Agent Mode should shine. Microsoft describes Agent Mode as capable of monitoring build and test results and iterating when failures occur.

Good.

Then make that behavior relentless.

If Copilot modifies code, it should automatically ask:

• Does it compile?
• Did I introduce warnings?
• Did I break a reference?
• Did unit tests fail?
• Did integration tests fail?
• Did static analysis detect something?
• Did I create a nullability problem?
• Did my change break another project in the solution?

And if the answer is yes:

Don't come back yet.

• Fix it.
• Build again.
• Test again.

Only then tell me you're finished.

That is what Agent Mode should mean.

How They Could Make This Better

The fundamental problem is that Copilot should stop behaving primarily like a chatbot that happens to know programming and start behaving like an AI software engineer integrated into Visual Studio.

Agent Mode is an important step toward that goal, but "agent" shouldn't merely mean that the chatbot gets permission to do more things.

It should mean the system takes responsibility for understanding, executing and validating a software-development task.

Build a Persistent Repository Brain

When I open a solution, Copilot should understand it.

Not merely whichever file happens to be open.

Index the repository.

Understand projects, namespaces, classes, interfaces, APIs, database access, configuration, tests, dependencies and architectural boundaries.

Construct a semantic map of the application and incrementally update it as the repository changes.

Then retain that knowledge.

If I ask:

"Where are we validating extension sessions?"

Find it.

If I say:

"Change the authentication flow."

Determine the affected components.

If I say:

"Why did yesterday's authentication change break image extraction?"

Understand enough project history to investigate the relationship.

If I return tomorrow, I shouldn't have to introduce Copilot to the application it spent yesterday modifying.

This is one area where competitors demonstrate why repository intelligence matters. Cursor emphasizes codebase indexing and agentic search, while JetBrains has been developing repository-context capabilities alongside its Junie coding agent.

Visual Studio should go further.

Visual Studio already possesses extraordinary structural knowledge about a .NET solution.

Exploit it.

Separate Conversation from Changes

Chat should contain communication.

The editor should contain code.

Agent Mode should work primarily against actual files while Chat becomes a command center.

Give me:

Task: Fix session expiration bug
Files analyzed: 17
Files modified: 2
Lines changed: +18 / -6
Build: Passed
Tests: 53/53
Potential regression: None detected
Confidence requiring review: Authentication retry behavior

Click anything to inspect it.

That is information density.

Hundreds of lines of scrolling chat are not.

Make Changes Surgical

Copilot should calculate the smallest reasonable patch capable of satisfying the request.

Changing five lines should normally produce a five-line change.

If Agent Mode wants to refactor 200 additional lines, make that a separately identified recommendation.

Optional refactoring discovered. Apply?

Don't sneak it into the task.

Better yet, give Agent Mode an explicit Minimal Change policy:

Accomplish the requested objective while modifying the smallest possible amount of existing code. Preserve unrelated code exactly unless a dependency requires modification.

For enterprise development, that should probably be the default.

Give Agent Mode a Blast-Radius Meter

Before an agent begins modifying code, tell me what it thinks will be affected.

Requested task: Fix login timeout

Expected impact:
2 methods
2 files
1 unit-test project

Then if the agent suddenly wants to change 19 files, stop.

Something changed.

Ask why.

That would catch one of the most dangerous characteristics of autonomous coding agents: task expansion.

Replace Line-by-Line Approval with Intelligent Review

Give developers control without turning them into human confirmation buttons.

• Accept change.
• Accept block.
• Accept method.
• Accept file.
• Accept task.
• Reject unrelated changes.
• And every Agent Mode task should automatically create a checkpoint.

One command:

Undo Agent Task

• Not Undo.
• Undo.
• Undo.
• Undo.
• Undo.

Restore the solution to exactly the state it occupied before the agent began working.

Make the Compiler Part of the Agent

Every meaningful Agent Mode change should trigger an automated verification loop:

• Edit.
• Compile.
• Inspect errors.
• Fix errors.
• Compile again.
• Run relevant tests.
• Inspect failures.
• Fix failures.
• Run static analysis.
• Check the Git diff for unintended changes.
• Summarize.

Only then:

Done.

And if it can't fix something, don't pretend the task is complete.

Say:

Task incomplete. Two tests still fail. Here is why.

That is much more valuable than artificial confidence.

Automatically Troubleshoot Incidents

Now take Agent Mode into production support.

Give it an exception, log entry, ticket or incident number.

Then tell it:

Investigate.

The agent should trace the exception through the repository, identify execution paths, inspect relevant configuration, examine recent commits, correlate logs, locate candidate root causes and propose a fix.

When possible:

• Reproduce the failure.
• Create a failing test.
• Implement the correction.
• Run the test.
• Run regression tests.
• Present the evidence.

The conversation changes from:

"Here are six files. Can you figure out what's wrong?"

to:

"Investigate incident INC-48217."

Now we're talking about an actual AI engineering companion.

Scaffold Entire Projects

And why stop at maintaining existing software?

I should be able to say:

"Create a .NET API for managing customers and orders. Use SQL Server, Entity Framework, JWT authentication, dependency injection, OpenAPI, structured logging, unit tests and integration tests."

Then go get coffee.

Agent Mode should create the solution, projects, directory structure, models, services, interfaces, controllers, configuration, migrations and tests.

• Restore packages.
• Compile.
• Find its own errors.
• Fix them.
• Run the tests.
• Fix those failures.

Then return with:

Solution created.
Build succeeded.
72 tests passed.
Architecture documentation generated.
Three design decisions require your review.

Cursor's Agent is already designed around multi-file autonomous work, codebase search and command execution. JetBrains' Junie similarly works through multi-step coding tasks and can run tests and terminal operations.

This is where development assistants are heading.

Let Agent Mode Actually Learn the Project

The ultimate development environment shouldn't have to rediscover the application during every conversation.

It should develop durable project knowledge.

• This is how authentication works.
• These are our architectural conventions.
• These components never directly access the database.
• This is our logging pattern.
• These tests protect the payment workflow.
• This API belongs to another team.
• Never modify generated files.
• Never change database schemas without approval.
• This subsystem is legacy.
• This service has a production compatibility requirement.
• These aren't merely chat memories.

They're the operating knowledge of the software project.

Combine repository analysis, source control history, architecture documents, developer instructions and previous Agent Mode work into a continuously maintained project model.

Then AI stops being autocomplete with a chat window.

It becomes institutional memory.

The Killer AI Companion Is Already Hiding in There

The frustrating thing about GitHub Copilot in Visual Studio isn't that the underlying AI is incapable.

It's that the workflow can prevent the technology from reaching its potential.

And Agent Mode makes that contrast even more obvious.

Microsoft already owns one of the richest development environments ever created. Visual Studio understands syntax trees, references, solutions, builds, tests, debugging, diagnostics and source control. GitHub provides repository infrastructure. Copilot provides increasingly capable AI models. Agent Mode provides the beginnings of autonomous execution.

The pieces are sitting on the table.

• Put them together properly.
• I don't want an AI that makes me continually identify files it could discover itself.
• I don't want a chatbot vomiting code into a scrolling window.
• I don't want mysterious whole-file replacements.
• I don't want unrelated working code disappearing.
• I don't want to press Tab fifty times.

I don't want an autonomous agent whose definition of autonomy is "I can now screw up more files without asking."

And I certainly don't want to tell an AI that the code it just wrote doesn't compile when the IDE hosting that AI already knows it doesn't compile.

I want to say:

"Here's the problem. Figure it out."

• Understand the repository.
• Remember what you learned.
• Determine the scope.
• Show me the expected blast radius.
• Make the smallest safe changes.
• Compile them.
• Test them.
• Find your own mistakes.
• Fix them.
• Tell me exactly what you changed.
• Leave everything else alone.
• And when I come back tomorrow, remember the application you spent all day working on.

That is what Agent Mode should become.

That would be a killer AI companion.

Visual Studio and GitHub Copilot already have many of the pieces necessary to build one.

Now they need to stop making the developer act as the agent's memory, file system, compiler, navigator, quality-control department and babysitter.