Agentic Architect
Cursor rules for .NET engineers who are tired of re-explaining the same architecture every morning.
Staff-level .NET teams protecting Clean Architecture, MediatR, Result<T>, and EF Core boundaries.
What it is: nine scoped .mdc files and a LEARNING_LOG.md protocol you commit beside your code.
Who it's for: staff-level .NET teams protecting Clean Architecture, MediatR, Result<T>, and EF Core boundaries.
Why it matters: Cursor has no memory between chats; this is the persistence layer that stops Wednesday drift.
.mdc rules, directory-scopedThe first 15 minutes of every Cursor session, you're not coding — you're re-explaining your codebase from scratch.
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 ↓Not another prompt dump. Directory-scoped AI coding rules plus a committed log so only the right guardrails load for the file you're editing.
Session 1 you tell Cursor "we use Result<T>, never throw in controllers." persistence.mdc appends that to LEARNING_LOG.md. Session 2 you open a new chat on OrdersController.cs; the hydrate prompt loads entry #14 and the model refuses throw new NotFoundException() without you repeating yourself.
## ADR-014 — API errors
- Controllers return Result<T>; no throw for business failures.
- Verified 2026-05-12 on OrderService refactor.Cursor invents IOrderRepository.FindByLegacyCode(), compile fails, it invents another fake method. After three failed attempts on the same file, bug-breaker.mdc stops generation and forces a re-read of the real interface before asking you.
Attempt 3 on OrderRepository.cs — halt.
Re-read IFileRepository.cs lines 12–48.
Ask user which lookup method exists.Four core engines below plus five more (result-pattern, ef-core-reads, api-conventions, testing, performance). Each loads only when relevant.
.cursor/rules/ — nine scoped .mdc files; Cursor loads only what matches the file you are editing.LEARNING_LOG.md — one-line ADRs and pitfalls; persistence.mdc tells Cursor to read it at session start.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.
agentic-architect-kit/ ├── .cursor/rules/ 9 × .mdc (directory-scoped) │ ├── arch-core.mdc, dotnet-di.mdc, bug-breaker.mdc, persistence.mdc │ ├── result-pattern.mdc, ef-core-reads.mdc, di-scoping.mdc, … ├── templates/ LEARNING_LOG.md + ADR starters (3 worked examples) ├── prompts/ hydrate-learning-log.md (one-shot seed from repo) ├── QUICKSTART.md install + hydrate in ~5 minutes └── LICENSE MIT — commit rules + log in team repos
Instant access via Payhip checkout. Payhip emails a download link with 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.
Early adopters are mostly solo staff engineers and small .NET teams. Below is what the kit is built to catch (from our published essays, not invented quotes).
throw in controllers. Result patternFrom our EF Core essay: teams reported data-layer PR review dropping from ~25 min to ~8 min after rule-governed Cursor usage (one production .NET 9 codebase, ~80 entity types). Your mileage will vary.
Free. No spam. Unsubscribe any time. By subscribing you agree to the Privacy Policy and Terms of Service.
£9.00 founder price via Payhip. Instant ZIP download. 30-day refund.
Everything you need to turn Cursor into a stateful architectural partner.
Senior .NET time is roughly £60–120/hr. This kit targets 2+ hours of Cursor re-regressions saved per sprint. Launch price: £9.00 (rises when the video walkthrough ships).
Checkout: Payhip · Delivery: instant ZIP via email · Refund: 30 days, no questionnaire · Updates: lifetime via repo
£9.00 founder price — locks in before the walkthrough video ships.
Long-tail reads that link back to the kit. Start with the Cursor rules for .NET overview.
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 £9.00 is worth that.
No. One-time £9.00. 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.
Payhip emails an instant download link after checkout. Unzip, copy .cursor/rules/ into your repo root, add LEARNING_LOG.md from templates/, run the hydrate prompt once.
Yes. MIT license covers internal use in your org's repos. One seat purchase, many repos, as long as you don't resell the kit as a competing product.
30-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 when the video walkthrough ships.
Drop the .cursor/rules/ folder in. Run the hydrate prompt once. Cursor picks up your architectural decisions on the next session.
One-time payment · Lifetime updates · 30-day guarantee · MIT-licensed