Agentic Architect is the only directory-level persistence framework that turns Cursor from a forgetful chat-bot into a stateful Architectural Partner that remembers your DI patterns, your boundaries, and your decisions — across every session.
.mdc rules engineered for C#/.NETLEARNING_LOG.md protocol — the "brain" of your projectBe honest. The first 15 minutes of every Cursor session, you're not coding — you're re-explaining your codebase to a goldfish.
That's 62 hours a year typing the same "we use Mediator and Result<T> in this project…" preamble. Your senior salary deserves better.
By mid-week it's suggesting HttpClient instantiations in your repository layer. Generic prompts can't enforce your SOLID boundaries.
The AI invents methods, doubles down when corrected, and burns tokens. There's no circuit breaker. So you become one.
Without persisted architectural rules, every PR slowly drags your clean architecture back into the swamp. You feel it. You can't stop it.
This isn't a Cursor problem. It's a persistence problem.
Show me the fix ↓
Agentic Architect isn't another prompt pack. It's a directory-level configuration system — 4 specialist .mdc rules + a stateful Learning Log — that loads only the right context for the file you're editing.
Each rule is engineered for a specific architectural concern, loaded only when relevant — so the AI is always sharp and never overloaded.
arch-core.mdc
Architecture
Enforces SOLID boundaries and prevents "Big Ball of Mud" suggestions. Stops the AI from crossing layer lines — no DbContext in controllers, no business logic in repositories, ever.
dotnet-di.mdc
.NET DI
A specialized auditor for constructor injections and service lifetimes. Catches Scoped → Singleton capture bugs before they ship. Knows IServiceCollection, Scrutor, Autofac patterns by heart.
bug-breaker.mdc
Circuit Breaker
A circuit-breaker that stops the AI when it enters a hallucination loop. Detects repeated failed solutions, forces it to step back, re-read the file, and ask — instead of doubling down.
persistence.mdc
★ The Engine
The engine that maintains your LEARNING_LOG.md — the persistent "brain" of your project. Every architectural decision, refactor reason, and "we tried that, don't do it again" lesson gets logged and re-hydrated automatically.
Instant access via Gumroad. You get the full .cursor/rules/ folder and a pre-seeded LEARNING_LOG.md template.
Copy .cursor/rules/ into your repo root. Cursor auto-detects the rules. No build step. No CLI. No config files to edit.
Run the included "hydrate" prompt once. The AI seeds your LEARNING_LOG.md from your codebase and starts tracking decisions automatically.
"I've burned hours every week fighting AI drift on a complex DDD codebase. The Learning Log alone paid for itself in the first afternoon. The DI auditor caught a Scoped-into-Singleton bug that would've shipped."
"The bug-breaker rule is genuinely novel. The AI used to spiral when it didn't know an answer — now it stops, re-reads the file, and asks me. That's the behavior I actually want from a senior pair-programmer."
"Finally — Cursor rules that respect token budgets. Scoped loading per directory means the relevant .mdc kicks in for that file, not a 2,000-token preamble on every prompt."
At your billing rate, you reclaim the cost in the first session. Then it compounds, forever.
Everything you need to turn Cursor into a stateful architectural partner.
Secure checkout via Gumroad · Instant download · VAT handled automatically
You could — and we did, over hundreds of hours, across real production .NET codebases. The framework isn't the prompts; it's the directory-level loading strategy, the circuit-breaker pattern, and the Learning Log protocol that gives Cursor true statefulness. Writing it yourself is a weekend project. Maintaining it is a second job.
Yes — that's exactly what it's built for. The .mdc files plug directly into Cursor's native rules system. We just use it with discipline.
The persistence.mdc engine and bug-breaker.mdc are language-agnostic. arch-core.mdc and dotnet-di.mdc are tuned for C#/.NET. If you're not in the .NET world, you'll get value from 2 of the 4 rules — your call whether £19.99 is worth that.
No. One-time £19.99. Lifetime updates. MIT-licensed. We hate subscriptions as much as you do.
Most public rules are monolithic — a single rule dumped on every prompt, blowing your token budget. Agentic Architect uses scoped, directory-aware loading so only relevant rules activate for the file you're in. Plus, none of them solve persistence — the actual root cause of AI drift.
They don't have to. The rules live in .cursor/rules/ and the Learning Log is just a markdown file. Both can be in .gitignore or committed for the team — your call.
14-day no-questions refund. Email agenticstandardcontact@gmail.com. We'd rather refund you than have an unhappy senior engineer telling their network.
Founder's pricing. It will go up. The countdown at the top is real — we raise the price each cohort to fund ongoing rule development.
Drop the .cursor/rules/ folder in. Hydrate the log. Watch your AI go from forgetful intern to stateful architectural partner — by tomorrow morning.
One-time payment · Lifetime updates · 14-day guarantee · MIT-licensed