The week of March 24-29, 2026. One person. Five active projects. Four hundred twenty-two commits pushed to GitHub.

Not a team. Not a sprint with eight engineers. One person amplified by an intelligence pipeline that knows the codebase, knows the preferences, knows the architecture, and delivers exactly the right context for every request.

Every commit is verifiable at github.com/bhandrigan. This isn’t a hypothetical case study. It’s a git log.

The Projects

Five repositories. Five different domains. All running simultaneously.

aios-v2 (gramatr platform): 206 commits. The intelligence pipeline itself — routing engine improvements, classifier training, new MCP tools, Kubernetes deployment automation, test suite expansion. The product being built was the product powering the build. Twenty-three of the platform’s twenty-seven server deployments happened during this single week.

n90-website-2026 (NEXT90 website): 154 commits. A complete corporate website — research, content strategy, information architecture, page design, SEO optimization, deployment. Not a template. A comprehensive, multi-page site built from competitive analysis and original research.

gramatr-ai-website: 19 commits. The website you’re reading right now. Research infrastructure, content planning, competitive analysis across five AI memory competitors, voice profile development, and the architecture for nine pages of content.

insights-datalake-dbt: 35 commits. Data pipeline work for NEXT90’s analytics engine. dbt models, data transformations, pipeline orchestration.

pen-test: 8 commits. Security testing and penetration test infrastructure.

What a Day Actually Looked Like

I’d start a session and gramatr already knew what I was working on. Not because it retrieved my last conversation — because it had learned my project patterns. The intelligence pipeline classified my first request, loaded the relevant project context, and delivered an intelligence packet scoped to exactly what I needed.

When I switched from writing Kubernetes manifests for gramatr to reviewing content drafts for the NEXT90 website, the context switched with me. Not because I told it to switch contexts — because the routing engine recognized the shift in intent and adjusted what it delivered.

When I moved from NEXT90 content back to gramatr’s test suite, the pipeline knew to load test conventions, coverage requirements, and the specific testing patterns we’d established. No re-explanation. No pasting architecture docs. No “let me remind you about our project.”

This is what context engineering does in practice. The intelligence pipeline handles the context management so the human can focus on the work.

The Before and After

The contrast matters because without it, the numbers are just numbers.

Before the routing engine went live (March 1-21), I was averaging 3.3 commits per day on the gramatr repo. Working on one project at a time. Sixty-nine total commits over twenty-one days.

After routing (March 21-28): 22.7 commits per day on gramatr alone. Three to five projects running simultaneously. One hundred fifty-nine commits on gramatr in seven days — more than double the entire previous three-week period.

The velocity increase wasn’t because I started working longer hours. It was because I stopped spending time on context management. The ten to thirty minutes at the start of every session, re-explaining the project state, re-loading the architecture decisions, re-establishing the conventions? Gone. The intelligence pipeline already knew.

That time — hours per week — went directly into building.

What Got Built

Let me be specific about what 422 commits actually produced, because “422 commits” is an abstract number without scope.

Two complete websites went from zero to deployed. Not landing pages. Comprehensive, multi-page websites with original research, competitive analysis, SEO architecture, and custom design. The NEXT90 website alone includes thousands of words of researched content across multiple pages. The gramatr website infrastructure includes a nine-page architecture, competitive analysis of five AI memory tools, and a complete content strategy.

The gramatr platform itself expanded significantly. The test suite grew to 2,471 passing tests across 128 test files. The knowledge graph reached 3,613 entities and 26,315 observations. The dynamic skill registry grew from seeded skills to twenty-three production skills — including the WriteWebsite skill that was created by the process of building the NEXT90 website, then immediately used to build the gramatr website.

A CRM system was stood up. New Kubernetes services were deployed. Data pipelines were built and tested. Security infrastructure was reviewed.

One person built all of that in a week. Powered by an intelligence pipeline that processed 4,189 queries and saved an estimated 20.9 million tokens through intelligent routing — delivering approximately 5,000 tokens per request instead of dumping the full context into every interaction.

What This Proves

I want to be careful here, because it would be easy to overclaim.

This doesn’t prove that gramatr will produce the same velocity increase for every user. It proves it for one user — me — working on my own projects, with an intelligence pipeline trained on my patterns over months of interaction. Your results will depend on your work patterns, your projects, and how much the system learns from your usage.

What it does prove, concretely and verifiably:

Context engineering works. The approach of classifying requests, routing context dynamically, and delivering targeted intelligence packets produces measurably better results than static system prompts or retrieval-only approaches. The 97% reduction in context (40,000 tokens to approximately 1,200 per request) with improved performance is architectural proof, not marketing.

Multi-project context switching is solvable. The common developer experience of losing thirty minutes every time you switch projects — re-loading context, re-establishing conventions, re-explaining architecture — is a context delivery problem, not a memory problem. When the intelligence pipeline handles the routing, switching projects takes seconds instead of minutes.

The system improves with use. The classification accuracy at the end of the week was measurably better than at the beginning. The feedback loop — where every interaction contributes to the classifier’s training data — means the pipeline gets smarter over time. Day seven was noticeably better than day one.

Everything is verifiable. This isn’t “our users report 7x productivity gains.” This is a public git log. Count the commits. Check the timestamps. Review the diffs. The evidence doesn’t require trust — it’s on GitHub.

The Skill That Built Itself

One detail from this week captures the gramatr philosophy better than any stat.

While building the NEXT90 website, the intelligence pipeline observed the repeating pattern of website content creation — research, architecture, page specs, content writing, QA cycles. It created a dynamic skill called WriteWebsite that codified that workflow.

The next day, when I started the gramatr.com website, that skill was already available. The process that built one website had taught the system how to build websites — and that learning was immediately applicable to the next project.

This is what “learns from interactions” actually means in practice. Not “remembers what you said.” Learns how you work, codifies it, and makes it available for the next task.

That’s not retrieval. That’s intelligence.

And it’s all in the git log.