Tips for using Cursor for Agentic Programming in productive teams (Without Compromising Architecture)

Intro:

Cursor is an AI-enabled code editor that helps engineers read, change, and generate code faster. In practice, the biggest shift is not “AI writes code for you,” but that the editor can now propose multi-file changes and assist with implementation work that used to be manual. 

If you’ve only seen autocomplete, this is a step beyond: in “agentic” workflows the tool can help coordinate changes across files and iterate based on feedback (like build and test results). It still needs constraints and verification, otherwise it produces output that looks professional but doesn’t fit your system. 

What follows are the practices we use to make Cursor valuable in real teams—practical, public-safe, and focused on repeatable engineering outcomes rather than hype. 

Note that while this document speaks specifically about Cursor, we present the learnings in a way that they are easily transferred to other tools such as GitHub Copilot or Claude Code as well. 

Learning 1: Documentation as code: encode decisions as rules 

Most documentation is passive: it’s written for humans, read inconsistently, and quickly drifts from reality. 

We treat the most valuable “documentation” as constraints that can be applied repeatedly: 

• architecture boundaries (“what can depend on what”) 

• conventions that reduce churn (errors, naming, layering) 

• explicit “don’t do this here” rules that prevent slow erosion 

  
  

This helps in two ways: Cursor stops guessing, and new team members onboard faster because “the normal way” is made explicit and close to the code. 

Rule hygiene matters: if rules become long essays, people ignore them and the tool treats them as noise. 

Learning 2: Build tools the AI can use to validate its own work 

AI tools increasingly behave like a probabilistic compiler: you provide intent, and they translate it into code that is often plausible — but still fallible. To get real value, we need to move from plausible to trustworthy. 

In our experience, one of the highestROI investments is a verification loop that is cheap, repeatable, and deterministic: 

1. one-command build/typechecks 

2. one-command lint/formats 

3. fast targeted tests (and clear failure messages) 

   
   

We use these verification steps actively in development to: 

1. Self-correction: when the agent has access to these tools, it can iterate on failures instead of guessing. 

2. Engineering hygiene: developers validate locally and CI enforces the same checks, so reviews focus on intent and risk—not avoidable breakages. 

Learning 3: Compounding improvements: turn learnings into reusable assets 

The biggest waste of resources with Cursor is relearning the same lessons repeatedly. 

When we discover something that we want to have the AI not repeat — an anti-pattern, a missing convention, a better prompt shape, a guardrail — we encode it in a reusable form: 

• a rule 

• a command/script 

• a prompt template 

• a lint/static check 

• a small automated validation 

  
  

We keep a central rules/recipes library in git that teams reuse and keep project-specific rules separate (because not every constraint generalizes).

The compounding effect is not “more rules,” it’s fewer repeated mistakes and more consistent execution. To get to an actual compounding flywheel it is paramount to make the process of contributing to the rules rules/recipes as easy as possible. 

Learning 4: Contract-driven development: “steel in the wall” 

Most AI-caused issues are ambiguity problems: unclear inputs/outputs, fuzzy ownership, implicit behavior. 

Strict contracts remove a lot of ambiguity. If you define boundaries with strong interfaces — e.g., protobuf schemas or similarly strict contract interfaces—you create “steel in the wall”: 

• the AI implements against a stable spec, 

• reviewers reason at the boundary, 

• tooling can validate compatibility. 

  
  

This doesn’t remove the need for tests, but it prevents a large class of “looks right, subtly wrong” changes. 

Learning 5: Microservices and modular boundaries work well (networked or in-process) 

This isn’t “microservices as ideology.” It’s about bounded contexts. 

AI tools perform best when the system is partitioned into units with: 

• a clear responsibility 

• stable interfaces 

• dependency direction 

• local verification 

  
  

Those boundaries can be network calls or in-process modules. The point is clarity of seams: when boundaries are real, Cursor’s work stays contained and reviewable. 

Learning 6: Type safety pairs well with LLMs 

Type systems and generated interfaces give AI-assisted development an objective feedback loop: 

• the compiler/typechecker catches mismatches immediately 

• errors are explicit and actionable, which helps iteration converge faster 

  
  

Types don’t replace behavioral testing, but they dramatically reduce the “unknown unknowns” that come from loosely specified structures. 

Learning 7: Encode architecture twice: in rules and in deterministic enforcement 

Rules are necessary. Deterministic enforcement is what makes them reliable at scale: 

• dependency rules (imports/layers) 

• lint rules blocking known bad patterns 

• contract compatibility checks 

• architecture tests 

• CI gates preventing boundary violations 

  
  

A useful heuristic: if a rule can be checked automatically, it should be. 

And yes—AI can help you write these linters and checks. The important part is that the guardrail itself is deterministic, reviewable, and consistently enforced. 

Learning 8: A practical note on “small diffs” vs “big scaffolding” 

In an existing codebase, smaller coherent slices usually win: easier review, safer verification, less accidental coupling. Keep a backlog of “next slices” rather than mixing many topics in one run. 

In a new project, generating larger scaffolding can be genuinely efficient (project structure, baseline modules, templates)—as long as it’s one coherent architectural slice and you verify immediately. Once real interfaces emerge, switch back to incremental slices. 

The failure mode is confusing current tools with too many unrelated objectives at once.