The AI Coding Compass — List View

What

A structural index of your entire repo: file tree, module relationships, and key entry points.

Why it matters

Modern harnesses work well even without a repository map, but having one definitely saves tokens.

Concept / Law

Garbage In, Garbage Out works for many parts of our life, applies here too. The output quality is bounded by input quality

What

The exact file being edited, sent in full with line numbers.

Why it matters

This might be the simplest thing on this list, but I'd still call it one of the most important. I'm using Codex in Visual Studio Code, and the command "Codex: Add File to Codex Thread" via the command palette is super handy.

Concept / Law

Ground Truth — the current file gives the model an accurate picture of the code it is expected to understand and modify.

What

Files that the current file imports, is imported by, or shares domain logic with.

Why it matters

When related files are missing, the model has to guess at interfaces and method signatures. Honestly, that's probably the biggest source of type errors I run into with AI-generated code. Maybe that's why I've grown so fond of C# and its clear static typing.

Concept / Law

<a href="https://connascence.io/" target="_blank">Connascence</a> (Page-Jones, 1992) — components that must change together are connascent. Reasoning about one side of a contract without the other causes headaches.

What

High-level structural constraints: which layers may depend on which, forbidden cross-cutting dependencies. <a href="https://mareks-082.medium.com/architectural-tests-in-net-1bd5d19b0ba8" target="_blank">Learn more</a>.

Why it matters

Without these, I've found the model will violate your architecture. LLMs have no problem adding a direct DB call straight into the presentation layer. Maybe it's time to write ADRs and back them up with architectural tests more consistently.

Concept / Law

Architecture Decision Records (ADRs) capture the architectural choices behind a system: the context, the decision, the alternatives considered, and its consequences. They give both developers and LLMs a source of truth.

What

Naming conventions, formatting rules, and style preferences specific to your codebase.

Why it matters

In one of our projects, we use non-standard two-space indentation instead of the usual four spaces in C#. LLMs fall back to four spaces surprisingly often, but a simple dotnet format check in CI/CD works wonders.

Concept / Law

Cognitive Friction — inconsistent style forces readers to perform extra mental work. Standards reduce that friction, so force your AI to not ignore them.

What

A glossary of project-specific terms: entity names, acronyms, and concepts unique to your business domain.

Why it matters

I've seen ambiguous terminology lead models to use the wrong synonym. "Account," "customer," and "user" may represent genuinely different concepts, so I'd rather define them explicitly than hope the model guesses correctly.

Concept / Law

Ubiquitous Language (Eric Evans, DDD) — shared vocabulary is a prerequisite for correct reasoning. Without it the model substitutes its own synonyms for yours.

What

Logged architecture decisions (ADRs) and major design choices that shaped the current codebase.

Why it matters

Without this type of context, I've noticed the model will happily re-propose something we already ruled out.

Concept / Law

Chesterton's Fence (1929) — don't remove a fence until you understand why it was built. LLM without ADR context confidently re-proposes the approaches you already rejected.

What

The actual failing test output: error messages, stack traces, and assertion diffs.

Why it matters

I've found vague error context tends to produce vague fixes. If you provide the exact failure output, LLM is much more likely to solve the problem.

Concept / Law

A related idea from cognitive science is the specificity of stimulation: the richer and more precise the input, the less inference is required. Likewise, a stack trace constrains the space of possible fixes in ways that a vague description cannot.

What

Error logs, exception traces, or performance metrics from your running system.

Why it matters

Production context tends to narrow things down dramatically. But don't provide too much data. Still again, it's worth spending a little time doing a first pass manually and gathering the (semi-)relevant information.

Concept / Law

Occam's Razor — when multiple explanations fit, prefer the simplest one consistent with the evidence. Production logs eliminates many unnecessary hypotheses.

What

Documents, code, APIs, and databases that can supply relevant context.

Why it matters

It's a no-brainer that retrieval works best when the source material is up-to-date and scoped to the task.

Concept / Law

Grounding — relevant external evidence narrows the space of plausible but unsupported answers.

What

Rules for selecting the smallest useful set of sources for a question.

Why it matters

It's easy to send the whole context and hope the LLM picks out what matters. Good retrieval gives it the relevant information without cluttering the context window.

Concept / Law

Information Retrieval — relevance ranking is the bridge between a large knowledge base and a focused prompt.

What

Splitting source material into retrievable pieces while preserving enough meaning.

Why it matters

It's about finding the right balance. Smaller chunks can lose context, while larger chunks can reduce retrieval precision.

Concept / Law

Semantic locality — useful chunks preserve the concepts needed to interpret the retrieved passage.

What

Vector representations that make semantically relevant material discoverable.

Why it matters

Embeddings help find relevant content by meaning, rather than just matching exact keywords. A random fun fact: I went to the same high school as Tomáš Mikolov, who later became one of the key researchers behind Word2Vec.

Concept / Law

Distributed representations — related concepts occupy nearby regions in a learned vector space.

What

A second pass that orders retrieved results by relevance before they reach the model.

Why it matters

Reranking improves precision when the first retrieval pass returns several plausible candidates.

Concept / Law

Precision before generation — better evidence selection gives the model fewer opportunities to follow a distracting passage.

What

Links or source references that make retrieved context inspectable and verifiable.

Why it matters

Citations make retrieval easier to verify, but you still need to know how to judge whether a source is reliable.

Concept / Law

Two-source rule — important claims should be confirmed by at least two independent sources.

What

Keeping indexed sources current so retrieval does not surface stale information.

Why it matters

Journalists have dealt with this problem for a long time: even a highly relevant source can be wrong if it's out of date.

Concept / Law

Journalistic currency — information should be recent enough to accurately reflect the situation being reported.

What

AI features built into editors like VS Code or JetBrains

Why it matters

I like that IDE assistants have such a narrow blast radius. Their suggestions stay local, they're fast, and I can easily reject them.

Concept / Law

Bezos' Two-Way Door: IDE suggestions are maximally Type 2 decisions — calls you can make fast and undo cheaply, unlike Type 1 decisions (one-way doors: hard to reverse. Every suggestion is just a draft, you can reject immediately.

What

Standalone chat UIs like Claude.ai or ChatGPT where you paste code and describe tasks manually.

Why it matters

Browser chat is not a good fit for me. It feels flexible, but it is disconnected from the IDE, so I have to rebuild context and manually double-check what comes out.

Concept / Law

Amnesia — the model retains no memory across sessions, forcing you to re-narrate context again and again.

What

Chat integrated into Visual Studio Code, with access to the files and code surrounding the task.

Why it matters

Visual Studio Code chat works well for me because it is part of the development environment. It can work with the code I'm looking at, and I can verify its suggestions in the IDE immediately.

Concept / Law

Grounded assistance — connecting chat to the current code and editor context makes the model more useful and its output easier to verify.

What

Command-line tools like Claude Code that can read your filesystem, run commands, and iterate on code autonomously.

Why it matters

CLI agents are the most capable tools, but also the riskiest.

Concept / Law

Principle of Least Privilege (Saltzer, 1974) — CLI agents have the widest blast radius of any AI.

What

Automated agents that trigger on pull request events.

Why it matters

I like PR bots because they provide automated code reviews with a great developer experience. The downside is alert fatigue: once they leave too many irrelevant comments, people tend to ignore them altogether.

Concept / Law

Alarm Fatigue (ICU/Security Operations) — when alerts are too frequent and low-precision, humans systematically stop responding.

What

AI-powered tools built specifically for your team's workflow like code generators that know your stack, custom review bots trained on your standards.

Why it matters

In the past, I vibecoded a few internal tools, but the harness keeps getting better, so right now I don't really see a strong reason to build a separate tool myself. In regulated environments, though, having a purpose-built tool can still make sense.

Concept / Law

Fit-for-Purpose Design — a simpler, targeted tool that solves your specific problem outperforms a powerful generic tool.

What

Model Context Protocol servers that expose structured tools (databases, APIs, internal systems) to AI models.

Why it matters

MCP feels like a way to give AI agents structured access to data without handing them raw shell access. I much prefer "read-only" MCP servers that retrieve the data the LLM needs. I'm still not entirely comfortable letting an LLM modify external systems, whether that's creating Jira tickets or restarting K8S pods.

Concept / Law

Principle of Least Privilege (Saltzer, 1974) — MCP implements capability-based security at the AI tool boundary; each server exposes only a narrow, well-defined interface rather than an open shell.

What

AI extensions that operate in the browser, assisting with tasks on web-based tools like GitHub, Jira, or internal admin UIs.

Why it matters

Browser copilots can save real time on repetitive web UI tasks, but they operate under your own session credentials. It means whatever they do, they're doing it as you. I'm not ready for that yet.

Concept / Law

Confused Deputy Problem (Hardy, 1988) — browser copilots are deputies holding your session token; if manipulated via prompt injection in a web page, they can take actions with your authority that you didn't authorize.

What

AI tools that generate, update, or query technical documentation — READMEs, API docs, architecture guides.

Why it matters

I've always felt that documentation starts rotting the moment it's written. Using AI to regenerate parts from the source code seems like a good way to keep docs up to date. On the other hand, I need to tone the LLM down from its default tendency to be overly poetic. Short sentences sound more intelligent than AI catchy phrases. I don't want things like "one folder, one source of truth" in my documentation.

Concept / Law

Documentation Debt — Ward Cunningham's technical debt metaphor applied to docs; AI documentation assistants pay this debt continuously rather than in large, painful batch updates.

What

The maximum number of tokens a model can receive in a single request, including both input and output.

Why it matters

If you exceed the context limit, it gets silently truncated. You then find yourself wondering why the LLM is suggesting a solution you already ruled out a few prompts ago.

Concept / Law

Miller's Law (1956): like human working memory, an LLM's effective reasoning is constrained by a finite context.

What

Condensing long files, logs, or conversations into shorter representations before sending to the model.

Why it matters

Raw content is, in my experience, almost always bloated with noise. A good summary can cut tokens by something like 70–90%.

Concept / Law

Semantic Compression. Natural language has high redundancy. We remember the gist of a conversation, not every sentence. Preserving the semantic gist is often sufficient LLMs, though not for every task. So be careful here.

What

Splitting large inputs into smaller, overlapping segments for separate model calls.

Why it matters

Chunking is my approach for managing codebases larger than any context window can accommodate. Although it inevitably sacrifices some relationships between chunks, I believe this tradeoff is worthwhile.

Concept / Law

Chunking (Miller) — humans increase effective working memory by grouping related items into coherent units.

What

Turning documents into vector representations to retrieve only the most relevant segments for a given query.

Why it matters

RAG is more or less the standard these days. It gives the model the context it needs without shipping the entire codebase over every single time.

Concept / Law

Associative Memory (Hopfield, 1982) — RAG is an engineered implementation of associative recall: instead of replaying all memory, you retrieve what is semantically proximal to the current query.

What

Algorithmically or manually removing redundancy from prompts before sending. It includes stripping boilerplate, comments, or verbose examples.

Why it matters

I believe that compressed prompts often produce better results. Models seem to attend better to dense text than to bloated context.

Concept / Law

Attention as a Scarce Resource — transformer attention is distributed across all input tokens; padding dilutes attention on important tokens, so compression can improve quality.

What

The choice between sending only the changed lines (diff) or the complete file for a given task.

Why it matters

Sending the full file feels safer to me, even if it costs a bit more. With diff-only, the model is more likely to lose track of the surrounding context.

Concept / Law

Local vs. Global Context — diffs are a relative representation requiring baseline knowledge of surrounding state; the tradeoff is a fundamental tension in any incremental processing system.

What

Calculating the token cost of a single AI-assisted action: review, generation, or explanation.

Why it matters

To be honest, I've been resource-conscious since childhood (even when I was playing strategic video games) so I'm a bit paranoid whenever I use the OpenAI API. <br/>Not everyone thinks that way, though. Some people need clearer(a.k.a. stricter) usage guidelines and spending limits.

Concept / Law

Marginal cost and opportunity cost — every AI-assisted action consumes a finite budget, so cost per operation helps compare the value against its financial resources.

What

Explicitly deciding which files or directories exclude from context. Sometimes, you don't need to send test fixtures, generated files, lock files, secrets.

Why it matters

Sending everything is a mistake I keep making. Too much noise often degrades the quality of the output while burning through tokens with little benefit.

Concept / Law

Via Negativa (Nassim Taleb) — define by what is excluded, not just what is included; lock files, generated files, and secrets are noise by definition, and noise degrades every downstream output.

What

Running the compiler or type checker immediately after accepting AI-generated code.

Why it matters

It turns out that LLMs work best when they can verify their own output and get a hint about what went wrong. The compiler is the cheapest and fastest verification we have.

Concept / Law

Fail Fast (Jim Shore) — systems should fail at the earliest detectable point.

What

Running the existing test suite against AI-modified code before merging.

Why it matters

Tests are the contract between what we intended to build and what actually got built. They make excellent guardrails for AI since the model gets a clear definition of correct behavior.

Concept / Law

Test as specification — a test is the clearest statement of intent an AI has access to, since it has no visibility into the reasoning behind the code, only the artifacts.

What

Running linters, code quality tools, or security scanners on AI-generated code.

Why it matters

AI learns from something like the average of what's out there on the internet, which unfortunately includes plenty of insecure or deprecated patterns. You can use static analysis to catch those issues automatically.

Concept / Law

Regression to the Mean — a model's output tends to drift toward the average quality of its training data. Static analysis helps pull it back above that baseline.

What

C#-specific static analysis rules built on the Roslyn compiler platform, catching patterns that generic linters miss.

Why it matters

Roslyn analyzers can enforce your team's architectural rules. They're another great part of the .NET ecosystem that makes working with complex C# codebases much easier.

Concept / Law

Poka-Yoke (Shigeo Shingo, Toyota Production System) — mistake-proofing by design; Roslyn analyzers encode architectural rules into the build system, making it impossible to merge violating code regardless of how it was generated.

What

Actively checking AI outputs for invented APIs, non-existent methods, or fabricated library versions.

Why it matters

I've noticed that AI models can confidently reference methods that don't exist. This is much more of a problem in dynamic languages. Strongly typed languages catch these mistakes very easily.

Concept / Law

Source Criticism (Historiography) — a claim is only as good as your ability to independently verify it; a type checker is one of the cheapest verifiers available for a claimed API.

What

Asking the model to reference the specific code or documentation it used to reach a conclusion.

Why it matters

An unsourced claim from a model is hard to verify. But when it cites the exact file and line it used, you can actually trace the reasoning and check it yourself.

Concept / Law

Epistemological Accountability — a belief is justified only if there is adequate evidence supporting it.

What

The principle that a model's tone of certainty carries no information about the accuracy of its output.

Why it matters

AI models sound just as confident when they're right as when they're completely hallucinating. I think mistaking confidence for reliability is a very human habit.

Concept / Law

Confidence heuristic — people often mistake confidence for competence. It doesn't work as well with people as with LLMs.

What

Developer effort is shifting from writing code to understanding code you didn't write.

Why it matters

The bottleneck has clearly shifted to code review, where comprehension matters far more than typing.

Concept / Law

Letovsky's Model of Program Comprehension (1986) — understanding code means understanding both what it does and why it was written that way. AI handles the "what" surprisingly well, but the "why" often disappears. That missing context increases cognitive load because you have to reconstruct the author's intent yourself. And unlike a coworker, the original author isn't around to answer questions.

What

A mandatory human review step before AI-generated code is merged or deployed.

Why it matters

I don't see human approval as a bottleneck. It's the one verification layer we can't really replace. AI can check syntax and patterns well enough, but only a developer can tell whether the code actually does what the business needs. If you're building a game for your kids like I am, skipping review is probably fine. But if you're shipping software people pay for, think twice before letting an LLM deploy code you haven't reviewed yourself.

Concept / Law

Human-in-the-Loop (HITL) — a human check is mandatory for high-stakes decisions.

What

Code that solves a textbook version of your problem rather than the actual, specific one in your codebase.

Why it matters

I think generic code quietly creates technical debt. Every codebase has its own patterns and conventions, often slightly different from the generic ones an AI reaches for. It works at first, but gradually becomes a liability as the code drifts away from how the rest of the system is actually built.

Concept / Law

Overfitting in Reverse — instead of fitting training data too closely, AI-generated generic code fits a canonical textbook problem and fails to generalize to your specific domain.

What

AI reaching for a well-known library that was free and open source when the model was trained, without knowing it has since switched to a paid or restrictive license.

Why it matters

Training data has a cutoff, but licenses keep changing after that date. MediatR and FluentAssertions were both free for years and then moved to commercial licensing, yet a model will still recommend them out of habit. Worth checking the license of anything an AI suggests before it ends up in your dependency tree.

Concept / Law

Knowledge Cutoff — a model reasons from a frozen snapshot of the world. Licensing terms are exactly the kind of fact that changes after that snapshot and never gets updated in the weights.

What

Adding abstractions, interfaces, and extension points for requirements that don't exist yet.

Why it matters

I've noticed AI seems to reach for enterprise patterns almost by default, regardless of how small the application actually is.

Concept / Law

YAGNI — You Aren't Gonna Need It (Ron Jeffries, XP) — implementing features for anticipated requirements is waste. AI over-engineers probably because enterprise patterns dominate training data and look sophisticated when post-training happens.

What

Abstractions that add indirection without adding flexibility, like base classes with one implementor, interfaces with one use.

Why it matters

These abstractions tend to feel professional, but they make code harder to read without making it any easier to change. I think of them as a bit of a tell for AI-generated code that's trying a little too hard to impress.

Concept / Law

Abstraction Inversion — a well-designed abstraction hides complexity behind a simpler interface. A fake abstraction adds complexity without reducing anything.

What

LLM applies design patterns when thinking it's enought recognizable as a pattern.

Why it matters

A misapplied pattern makes life harder for every developer who reads the code afterward. A simple if-statement dressed up as a Chain of Responsibility is a pretty reliable sign of AI slop.

Concept / Law

Law of the Instrument (Maslow, 1966) — if the only tool you have is a hammer, every problem looks like a nail. AI has seen millions of pattern examples and applies them regardless of whether the problem calls for them.

What

AI comments and docstrings that describe what code does without explaining why it's structured the way it is.

Why it matters

It's well-known that comments which simply restate the code don't add much value. The ones I find useful explain a non-obvious constraint or trade-off and, most importantly, why the code is written that way.

Concept / Law

Mutual Information (Shannon) — A useful comment anticipates the questions a future reader is most likely to ask and provides the missing information needed to answer them.

What

Code that is syntactically valid C# but written in a style foreign to the language, like Java-ish patterns or outdated pre-C#8 idioms.

Why it matters

Non-idiomatic code just tends to be harder to review and maintain. I like to think of idiomatic style as a kind of shared communication standard for the team.

Concept / Law

Linguistic Register — code has also registers: idiomatic C# uses properties, LINQ, and records in specific ways. Non-idiomatic code is technically grammatical but obviously non-native, violating the Principle of Least Surprise for every reader.

What

Code that appears simple on the surface but contains subtle performance traps, race conditions, or edge-case failures.

Why it matters

Current LLMs tend to produce code that looks right in isolation, while the hidden complexity becomes visible later, under load or concurrency.

Concept / Law

First-order effects are what the code directly does. Second-order effects are what the system does because the code exists. Hidden complexity often lives in these second-order effects—they remain invisible in isolated tests and only emerge through interactions with production load and real users.

What

The hardest slop to catch. It's code that passes review but fails in production.

Why it matters

Professional-looking output is fairly easy for AI to produce. Actual correctness under real conditions needs domain knowledge the model either doesn't have or wasn't given. Another reason I still consider human approval non-negotiable.

Concept / Law

Batesian Mimicry (Evolutionary Biology) — some organisms mimic the appearance of healthy counterparts without sharing the underlying properties. AI slop mimics well-engineered code while lacking its correctness.

What

Treating prompts as code, running them against test cases, and rolling back regressions.

Why it matters

Without versioning your prompts, I don't think you can really tell whether a change made things better or quietly broke something.

Concept / Law

If It's Not in Version Control, It Doesn't Exist — Treat your prompts like code and put them in Git.

What

Curated input/output pairs that represent correct behavior for your AI feature.

Why it matters

I like golden datasets because they give you a concrete way to verify whether a model change actually improves the results. Without them, you often end up relying on “it seems to work.” I don't think that's a strong enough signal once you're running the model in production.

Concept / Law

Ground Truth (Machine Learning) — golden datasets define what 'correct' means for your specific use case, independent of any model's opinion. You can see them as unit test fixtures.

What

Automated checks that run your AI feature against golden datasets and flag output changes.

Why it matters

I've found that model upgrades, prompt tweaks, and even small context changes can quietly make the output worse. You often don't notice it until the change has already caused problems.

Concept / Law

Behavioral Contracts — regression tests encode the expected input/output relationship of your AI feature. When that contract is violated by a model update or prompt change, they make the violation explicit.

What

Running the same inputs through multiple models to compare output quality, cost, and latency.

Why it matters

I don't think you always need the most capable model. You need one that consistently meets your quality bar while keeping the cost at a level you're comfortable with.

Concept / Law

Goodhart's Law — public benchmarks measure aggregate capability. It's fun to talk about public benchmarks but the only reliable comparison is your own golden dataset.

What

Logging token usage and dollar cost per AI operation in production.

Why it matters

Without cost tracking, AI usage can grow surprisingly quickly and catch you off guard. I think you should treat FinOps as a core part of running AI in production, just like you do with the rest of your cloud infrastructure.

Concept / Law

FinOps — you cannot manage what you cannot observe. Cost tracking is the financial observability layer of an AI system.

What

Measuring p50, p90, and p99 response times for AI-assisted operations.

Why it matters

Average latency can easily hide the problems your users actually feel. I think you should pay close attention to the slowest requests, because that 1% taking 30 seconds can quickly make the whole system feel unreliable.

Concept / Law

Heavy-Tailed Distributions — AI inference latency is not normally distributed. p99 latency captures what users experience in the worst case, and the worst case determines UX.

What

Tracking how often AI suggestions are accepted, modified, or discarded by developers.

Why it matters

I think acceptance rate is one of the best signals you have for measuring the value of AI-generated code. If you keep rejecting most of what the model produces, you should probably look at the context, prompts, or model and figure out where things are going wrong.

Concept / Law

Revealed Preference (Paul Samuelson) — what people do is more informative than what they say; actual accept/reject behavior is the honest signal that cannot be faked, unlike self-reported satisfaction surveys.

What

Using a ticket or issue description as the starting context for generating implementation code.

Why it matters

This is easily one of AI's biggest time savers for me. Getting a rough first implementation almost instantly helps me get past the "where do I even start?" phase. That small dopamine hit is often all I need to get moving.

Concept / Law

Activation Barrier — the hardest part of many tasks is simply getting started. By turning a ticket into an initial implementation, AI lowers the mental effort required to begin, replacing a blank page with something concrete to iterate on.

What

Generating test cases from existing implementation code.

Why it matters

I've found AI helpful for surfacing untested paths. Give it a function and it'll enumerate edge cases you might not think of. Though it can get a bit purist too, I've seen it suggesting multithreading checks for code that never runs concurrently.

Concept / Law

Path Coverage — AI exhaustively enumerates branches that humans under deadline skip.

What

Passing a compilation error or runtime exception directly to the model to get a targeted fix.

Why it matters

An error message provides concrete context, which narrows the space of possible fixes. You can usually verify whether the proposed solution works almost immediately. It can be misleading sometimes but it's surprising how often this approach works well.

Concept / Law

Constraint-Based Reasoning — the more specific the input and the smaller the solution space, the more reliably a model can produce a useful answer.

What

Using a pull request diff as context for generating a structured code review.

Why it matters

I've found AI reviews to be useful as a first pass. Sometimes they hallucinate about hypothetical edge cases, but sometimes they catch real issue.They're often good enough to point me toward areas worth a closer look.

Concept / Law

Signal Detection Theory (Tanner & Swets, 1954) — AI reviews don't need to be perfect to be useful. If they catch a few real issues and save me from manually checking everything, they've done their job.

What

Starting from a high-level design document or ADR and generating a scaffold or skeleton implementation.

Why it matters

Turning architecture decisions into actual code has always felt tedious to me. AI can give you a quick starting point that more or less matches the intended structure. See the 'ticket → code' section.

Concept / Law

Model-Driven Development — a high-level specification transformed into a concrete artifact.

What

Converting raw meeting notes or decision logs into structured backlog items.

Why it matters

In my experience, meeting transcripts are mostly noise. AI can do a decent job of extracting the action items, but I still treat the result as a draft that needs review.

Concept / Law

Signal Extraction: Meetings are high-bandwidth but low-density communication. AI can extract the underlying decisions from the unstructured discussion.

What

Facts, preferences, and decisions retained across sessions.

Why it matters

Without it, every session starts from scratch, and users have to explain the same context again and again. But stale facts can also quietly steer the model's answers, so users need to be able to see and correct what's stored.

Concept / Law

Persistent state is useful only when its provenance and lifetime are clear.

What

Selecting only memories relevant to the current task.

Why it matters

Unfiltered memory can quickly become noise. I notice this with ChatGPT when I'm writing a blog post: it uses what it has learned about the topic to give me more relevant answers. But once I've finished the post, it keeps bringing that context into unrelated conversations.

Concept / Law

Garbage collection: retained state needs an explicit lifecycle.

What

AI-generated code review comments on a pull request diff.

Why it matters

AI review is consistent and catches mechanical issues at scale. That said, it has no real opinion on whether a feature makes sense or fits the system. That part is still on you.

Concept / Law

Raising the Floor vs. Ceiling - AI PR review guarantees a minimum quality bar(raising the floor) on every PR regardless of reviewer availability but still it have limitation and really can't cover everything(the ceiling)

What

Using AI to generate test cases from code.

Why it matters

AI does seem to find paths through code that a developer might overlook under pressure. But are the tests actually proving the right thing? I've noticed AI-generated tests can be a bit optimistic, so always double-check the assertions.

Concept / Law

Mutation Score vs. Line Coverage — AI-generated tests often achieve impressive line coverage, but that can be misleading. Sometimes, I must push the model to improve the mutation score; otherwise, you may end up with tests that execute the code without verifying anything meaningful.

What

Generating release notes or changelogs from commit history or PR descriptions.

Why it matters

Hand-written changelogs, in my experience, have a habit of becoming incomplete. Someone forgets an entry, someone else uses a different level of detail. AI can take the raw commit history and turn it into a reasonably good summary for users.

Concept / Law

Lossy Compression — a changelog is a lossy compression of git history that preserves user-relevant changes and discards implementation details.

What

Automatically updating READMEs, API docs, or architecture guides when code changes.

Why it matters

Documentation debt has a way of piling up quietly, I've found. Automating the update cycle helps keep docs accurate without asking everyone to remember to do it.

Concept / Law

Documentation Decay Rate — documentation has a half-life that decreases with codebase velocity.

What

Architecture Decision Records — structured documents capturing what was decided, why, and what alternatives were rejected.

Why it matters

Without ADRs, I think important decisions tend to disappear into people's heads and old Slack(or Teams, in the worst case) threads. AI can help capture discussion into form of an ADR draft.

Concept / Law

Institutional Memory (Peter Senge) — teams repeatedly solve the same problems because decisions are not recorded. ADRs are the canonical solution, and AI lowers the cost of creating.

What

Using AI to analyze dependencies and generate a step-by-step plan for a large-scale code migration.

Why it matters

Manual migration planning tends to miss edge cases, at least in my experience. AI can trace the dependency graph and find affected files that are easy to overlook. I think that makes the scope much easier to see. You should always prefer a concrete checklist to a vague multi-week estimate.

Concept / Law

Topological Sort (Graph Theory) — large migrations have a dependency partial order; the correct migration sequence is a topological sort of the dependency graph, which AI can compute from import analysis while humans doing it manually miss edges.

What

Mapping which modules, packages, or services depend on a given component before changing it.

Why it matters

I think dependency surprises are one of the easiest ways to introduce regressions. You can use AI to trace your dependency graph and spot what might break before you even rename a function.

Concept / Law

Law of Demeter (Lieberherr & Holland, 1987) — systems that violate 'talk only to your immediate friends' have deeply tangled dependency graphs.

What

An AI tool that answers 'where is X?', 'how does Y work?', and 'who owns Z?' using your codebase and docs as context.

Why it matters

Onboarding can easily take weeks because the knowledge you need is scattered across the company and your team. You usually get an onboarding buddy too, but they have their own work and aren't always available.

Concept / Law

Expert's Curse (Knowledge Blindspot) — senior engineers are often the worst onboarding guides because they've lost the ability to see what's non-obvious.