Scoped Cursor rules for .NET teams
Nine directory-scoped .mdc rules plus a LEARNING_LOG.md workflow. Cursor loads the right guardrails per file and picks up decisions you already logged.
Built for teams running Clean Architecture, MediatR, Result<T>, and EF Core with real layer boundaries.
Pick a real .NET scenario and watch Plain Cursor vs the kit-loaded Cursor respond.
Interactive preview. Illustrated scenarios based on real .NET/Cursor patterns. Install the kit in your repo for this behaviour in Cursor.
What it is: nine scoped .mdc files and a LEARNING_LOG.md protocol you commit beside your code.
Who it's for: senior .NET engineers who use Cursor daily and care about DI, EF, and layer boundaries.
Why it matters: Cursor starts fresh every chat. The log and scoped rules carry your stack context forward.
.mdc rules, directory-scopedbug-breaker.mdc)The first chunk of every session goes to re-explaining your stack. MediatR, Result<T>, where EF belongs, what you decided last sprint. That is repeatable work, not coding.
You type the same project conventions again. Mediator in the application layer, no throws in controllers, EF stays in infrastructure. At senior rates, that adds up fast.
Without persisted rules, Cursor starts suggesting HttpClient in repositories or DbContext in controllers. Your SOLID layout erodes one suggestion at a time.
The model invents APIs that do not exist, tries again, tries again. You end up as the circuit breaker manually.
Without rules committed to the repo, each PR nudges the codebase toward shortcuts. You notice it in review. The kit is meant to catch that before merge.
This is not a Cursor bug. It is a persistence gap.
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 the file path matches.
.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
Keeps suggestions inside your layers. No DbContext in controllers, no business logic in repositories.
dotnet-di.mdc
.NET DI
Catches Scoped → Singleton capture bugs before runtime. Covers IServiceCollection, Scrutor, and common Autofac patterns.
bug-breaker.mdc
Circuit Breaker
After several failed attempts on the same file, generation halts. Cursor re-reads the real source and asks instead of inventing another fix.
persistence.mdc
★ The Engine
Appends architectural decisions, refactor notes, and "we tried that" lessons. The hydrate prompt loads them at session start.
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 buyers are mostly solo staff engineers and small .NET teams. Below is what the rules target, drawn from our published essays (not invented testimonials).
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.
Scoped .mdc rules, a committed learning log, and a hydrate prompt. Copy into your repo, run once, done.
Senior .NET time runs roughly £60–120/hr. If the kit saves you one avoided DI bug or one less re-brief per sprint, it pays for itself. 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. We did, over a long time, across production .NET repos. The value is not one mega-prompt. It is directory-scoped loading (only relevant rules per file), the LEARNING_LOG.md protocol, and bug-breaker.mdc for retry loops. Writing a first draft is a weekend. Keeping it aligned with Cursor updates and your stack is ongoing work.
Prompts live in chat and vanish when the thread closes. .mdc rules live in .cursor/rules/ and load automatically based on file path. The hydrate prompt runs once to seed LEARNING_LOG.md; after that, persistence.mdc maintains the log across sessions. Rules enforce. Prompts inform.
Yes. That is what it is built for. The .mdc files plug into Cursor's native rules system.
persistence.mdc and bug-breaker.mdc are language-agnostic. Seven of the nine rules are tuned for C#/.NET (DI, EF Core, Result<T>, API, testing, and related guardrails). Non-.NET users get value from the persistence and circuit-breaker rules. Whether £9.00 is worth two of nine is your call.
No. Solo staff engineers were the first buyers. You still re-brief Cursor every session and still need boundaries enforced when you are the only reviewer. The free starter kit (3 rules) is enough to test the workflow before paying.
No. One-time £9.00. Lifetime updates. MIT-licensed.
Most public rules are one big file loaded on every prompt. Agentic Architect scopes rules by directory so only relevant guardrails activate. Most repos also skip persistence — no LEARNING_LOG.md workflow to carry decisions forward.
They do not have to. Rules sit in .cursor/rules/ and the log is a markdown file. Keep them personal in .gitignore, or commit them for the team. One purchase covers internal use under MIT.
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 refund. Email agenticstandardcontact@gmail.com.
Founder's pricing. It will go up when the video walkthrough ships.
Copy .cursor/rules/ into your repo. Run the hydrate prompt once. Your next Cursor session loads the log and scoped rules automatically.
One-time payment · Lifetime updates · 30-day guarantee · MIT-licensed