Context Architecture
How a codebase explains itself — context files, documentation and conventions structured so the right material is found at the right time, by a person or a tool.
Measuring Whether Your Context File Helps: A Practical Evaluation Method
A repeatable way to test whether AGENTS.md changes actually improve agent behaviour: representative tasks, objective scoring, controlled comparison, and enough runs to beat variance.
Declaring Off-Limits Paths: Generated Code, Migrations and Secrets
The four categories of file an agent must not edit, why each entry needs an escape hatch, and the one line that stops an agent disabling your CI checks.
Agent Context Across Many Repositories: Carry Contracts, Leave the Rest
Nested context files solve monorepos and do nothing for fourteen separate services. What must cross a repository boundary, why vendoring contracts works, and how to sequence cross-service work.
Token Budget in Multi-File Refactoring: Sequencing Over Squeezing
Where the context budget actually goes during a large refactor, reading signatures instead of implementations, bounding tool output, and staging work so each session can discard the last.
AGENTS.md vs CLAUDE.md vs .cursorrules: When One File Isn't Enough
Whether to keep one context file or several, the three cases where a second file is justified, and why the symlink workaround usually disappoints.
Agent Memory: Four Layers, and Which One Is Worth Building
Nothing persists that you did not persist deliberately. The four things people mean by agent memory, why task handoff pays first, and why recording dead ends matters more than recording progress.
The AGENTS.md Specification: Anatomy of a Repository Context File
What belongs in an AGENTS.md file, the six sections that carry the weight, why short files outperform comprehensive ones, and where context files stop working.
Writing Build and Test Instructions an Agent Can Actually Execute
Five ways 'run the tests' fails in practice, how to separate the fast loop from the merge gate, and why pointing at one CI-backed script beats fifteen lines of prose.
Dependency-Ordered Context: Rank by Structure, Not Similarity
Why import graphs predict relevance better than semantic similarity, reading imports in full and importers as signatures, excluding hub modules, and telling the agent what you left out.
Context File Size and Token Budget: Measuring What You Can Afford
Why the context window is a budget rather than a container, how position affects which rules actually influence behaviour, and a concrete token budget for root and package files.
Versioning and Reviewing Context Files as Source Code
Why an AGENTS.md change has a wider blast radius than most code changes, five questions worth asking in review, and two forcing functions that stop the file growing forever.
RAG for Runbooks: The Narrow Case Where Internal Retrieval Works
Why most internal-documentation RAG disappoints and operational content does not, structural chunking, returning provenance and age, hybrid retrieval for error codes, and measuring recall@5.
Encoding Architectural Constraints and Module Boundaries for Agents
Why naming your architecture pattern doesn't work, how to state dependency directions as checkable rules, and why every prohibition needs an escape hatch.
Why Duplicating Your README Into AGENTS.md Makes Agents Worse
Copying project overview into a context file measurably degrades agent performance. The three mechanisms behind it, and a discoverability test for deciding what to cut.
AST-Based Repository Indexing: Giving an Agent Exact Answers
Why text search returns confidently wrong answers in codebases with interfaces, a forty-line symbol index you can build with the standard library, and how to keep it from going stale.
Scoping Agent Context in Monorepos: Nested Files and Precedence
How to split AGENTS.md across a monorepo so each package carries its own rules, why precedence follows proximity, and how to verify your tooling actually reads nested files.
Other pillars
- Security Engineering — Threat models, trust boundaries and controls for systems that hold credentials, execute code and call tools on your behalf.
- Tooling & Integration — How the pieces fit together: editors, build systems, CI, protocols and the day-to-day mechanics of shipping software.
- Workflow Architecture — Designing the loops work happens inside — instruction design, migrations, test-driven cycles and the gates that keep a codebase coherent over time.
- Codex vs Claude — Practical comparisons across execution, security, cost, speed, orchestration, planning, integrations and verification — each examined as a decision a working developer can test.
- Higgsfield AI — A practical field guide to Higgsfield's generation, camera, consistency, advertising, audio and editing workflows — including the limits hidden by feature names and the checks that prevent wasted renders.
- Flow vs Higgsfield — A beginner-focused comparison of Google Flow and Higgsfield across models, mobile use, story building, camera control, editing, integrations and the real cost of accepted video.
- Humanoid Robots — Practical buying guides for commercially offered humanoid robots, separating published specifications from configuration, integration, safety, privacy and procurement obligations.
- ChatGPT vs Grok vs Claude Code — A practical comparison of three increasingly broad AI products across identity, interfaces, files, autonomy, search, coding, media, memory, integration, safety and the work each is best equipped to own.
- Tesla Roadster — Evidence-aware engineering guides to twenty-five announced, proposed and prototype Roadster features — separating Tesla's published targets from executive claims, visible concepts, engineering inference and unsupported expectations.