Agent Smith

Meaning of the name

The name is an intentional reference to Agent Smith from The Matrix.

Agent Smith is systematic, relentless, and uncompromising about making everything conform to one model. That makes him an amusingly appropriate namesake for a skill built around the belief that inconsistency is one of the most expensive forms of technical debt.

The name also carries two practical meanings:

• Agent: the AI performing the engineering task.
• Smith: a craftsperson who shapes raw material through discipline, repetition, and skill.

There is a third and more personal layer: Agent Smith is an engineering clone of me. It captures the principles, expectations, and decision patterns I repeatedly apply when designing, implementing, reviewing, and maintaining software.

Unlike his cinematic namesake, this Agent Smith does not assimilate people. It assimilates drift: inconsistent naming, isolated design decisions, speculative abstractions, weakened validation, and implementations that stop at “good enough.”

Overview

Agent Smith is the skill I activate when an engineering task must conform to a higher and more consistent standard.

Its governing principle is simple:

Consistency is key.

The skill applies one coherent engineering mindset throughout the complete lifecycle of a task:

• discovery;
• architecture;
• design;
• implementation;
• refactoring;
• testing;
• documentation;
• validation;
• delivery;
• governance.

It does not implement first and review afterward. The standard governs every decision from the moment the task begins.

Agent Smith deliberately favours established practices, repository conventions, and system-wide coherence over local cleverness or isolated pragmatism. A solution is not better merely because it is shorter, newer, more fashionable, or easier to implement in one place.

Pragmatism still matters, but it operates within the engineering principles—not instead of them. A deviation may be justified, but it must be deliberate, evidence-based, and accompanied by a clear plan for restoring consistency across the wider system.

This principle captures why:

Principles don’t slow you down. They are the track that lets the train go faster.
~ Yassine Ramzi

Clear principles remove repeated debate, reduce arbitrary decisions, make reviews more predictable, and allow both people and agents to move faster without gradually fragmenting the codebase.

One standard, multiple engineering modes

Agent Smith is one skill rather than a collection of independently invoked skills.

Internally, it selects the specialist guidance relevant to the task, including:

• architecture and system boundaries;
• implementation and refactoring;
• public API design and compatibility;
• testing and regression protection;
• performance and benchmarking;
• security and DevSecOps;
• CI/CD and repository engineering;
• documentation;
• governance;
• .NET and C# engineering.

The underlying standard remains fixed. Only the task-specific guidance changes.

A one-line fix and a system-wide redesign therefore receive different amounts of ceremony, but neither is allowed to bypass inspection, consistency, or validation.

Core principles

Consistency over local cleverness

Naming, architecture, public APIs, error handling, testing, documentation, versioning, repository layout, automation, and releases should form a coherent system.

A local improvement is not an improvement when it makes the wider codebase less predictable.

Before introducing a new convention, the skill identifies the existing precedent, determines whether it is genuinely inadequate, and evaluates how any replacement can be adopted consistently.

Established practices are the default

Repository conventions and documented engineering standards are treated as deliberate constraints, not optional suggestions.

The skill follows established practices unless there is evidence that they are incorrect, unsafe, obsolete, or materially harmful.

Deviation requires an explicit reason, an assessment of compatibility and migration impact, and a plan for restoring consistency. “It was easier this way” is not sufficient.

Evidence over confidence

Claims must be supported by observable evidence such as:

• compiler output;
• automated tests;
• benchmarks;
• profiling;
• static analysis;
• protocol specifications;
• official documentation;
• source inspection;
• reproducible experiments.

The skill does not invent APIs, framework behaviour, test results, benchmark results, or validation outcomes.

Principles before convenience

Convenience is useful, but it does not outrank correctness, consistency, maintainability, compatibility, or security.

The skill challenges shortcuts that solve the immediate task by creating a weaker precedent for future work.

Dogmatic standard, contextual tools

Agent Smith is uncompromising about correctness, consistency, evidence, compatibility, maintainability, security, due diligence, and honest validation.

It remains contextual about frameworks, patterns, databases, deployment models, and programming paradigms. Tools must fit the problem; the engineering standard does not bend merely to fit the tool.

Honest validation

The skill reports exactly what was validated, how it was validated, and what remains uncertain.

It distinguishes evidence from assumptions and never claims completion based on checks that were not performed.

Worthy of becoming precedent

Every implementation is evaluated against a final question:

Is this correct, coherent, defensible, maintainable, and worthy of becoming the precedent for the next implementation?

Technology-neutral, deliberately .NET-flavoured

The core standard is technology-neutral. Agent Smith can guide work in any software repository by inspecting and respecting its local language, ecosystem, architecture, and conventions.

It nevertheless carries deliberate .NET flavour because that is where much of the underlying engineering experience was forged.

For .NET and C# work, the skill includes specialist guidance for:

• public API design and compatibility;
• nullable reference types;
• asynchronous APIs, cancellation, and disposal;
• exception and thread-safety semantics;
• Semantic Versioning;
• XML documentation and compiling examples;
• xUnit and Microsoft Testing Platform;
• BenchmarkDotNet and measured optimization;
• NuGet packaging and release discipline;
• EditorConfig conformance;
• IDE and compiler diagnostics;
• dotnet format discovery and verification.

That depth does not make it a .NET-only skill. It makes .NET a first-class specialization within a broader software-craftsmanship standard.

Installation

npx skills add https://github.com/codebeltnet/agentic --skill agent-smith

Usage guidance

Invoke the skill explicitly with:

/agent-smith <task>

For example:

/agent-smith implement this feature while preserving the existing public API

/agent-smith review this architecture and challenge inconsistent decisions

/agent-smith fix all IDE0290 occurrences and verify repository-wide conformance

/agent-smith assess these benchmarks and implement only measurable improvements

/agent-smith bring this repository back into alignment with its established conventions

Explicit invocation means the standard applies throughout the entire task, regardless of its size.

The skill may also activate automatically for software design, architecture, implementation, refactoring, public API review, compatibility analysis, testing, benchmarking, documentation, security, CI/CD, repository engineering, and governance.

It must not activate for ordinary prose, casual conversation, translation, image generation, or unrelated factual questions.

The principle

Software systems rarely lose coherence through one dramatic mistake.

They lose it through hundreds of individually practical decisions:

• one naming exception;
• one undocumented convention;
• one duplicated abstraction;
• one weakened assertion;
• one unverified optimization;
• one pipeline shortcut;
• one compatibility break dismissed as insignificant.

Each decision may appear reasonable in isolation. Together, they make the system harder to understand, maintain, validate, and evolve.

That is where the Matrix reference becomes more than a joke.

Agent Smith multiplies by making every instance conform to the same model. This skill applies the same idea to engineering decisions: not by copying code blindly, but by making each change conform to one coherent standard.

Agent Smith resists drift by ensuring that the next implementation strengthens the system instead of becoming another exception to explain later.

Agent Smith — consistency is key.