Live MCP injection
Agents load your rules during the session — before code is generated — not as a post-hoc checklist.
Engineering standards for AI coding
DevLaws turns software engineering principles and team conventions into live guardrails. Connect once via MCP — Cursor, Claude Code, Copilot, and others follow the same standards.
The problem
Static rule files go stale. Lint catches syntax, not architecture. Each engineer’s agent invents its own style. DevLaws is a living protocol: one set of rules, injected into every connected agent, kept in sync for the whole team.
What you get
Agents load your rules during the session — before code is generated — not as a post-hoc checklist.
Define one protocol for the org. Every developer’s agent follows the same architecture and quality rules. New hires inherit the standard on day one.
Group laws by theme — security, API design, performance — and share them across teams or import community packs.
Unlike .cursorrules files that rot in the repo, protocols sync
when you change them. Toggle a rule; connected agents pick it up.
Ask engineering questions and get answers grounded in established principles — useful for architecture debates, not just autocomplete.
Scoped keys for MCP auth. Rotate or revoke per team without disrupting others.
Coverage
Architectural and process issues that standard linters miss — framed by well-known engineering principles.
God classes, circular dependencies, tight coupling, service boundaries that fight your org chart.
N+1 queries, missing error boundaries, uncapped loops, and cost traps in generated code.
Hardcoded secrets, weak validation, missing auth checks, unsafe API flows.
Hallucinated APIs, deprecated calls, over-abstraction, and boilerplate bloat.
Deviations from naming, module layout, and conventions your team already agreed on.
Single points of failure, untestable paths, and complexity that grows without ownership.
How it works
Start from 110+ engineering laws, or write custom ones for your stack and org.
Pick what is active. Share it with your team or keep it personal.
Connect supported IDEs and CLIs to DevLaws. Rules apply in-session.
Integrations
One protocol. Multiple agents. No need to maintain a separate rules file per tool.
Principles
Classic heuristics, mapped to concrete checks — plus room for your own rules.
Anything that can go wrong, will go wrong.
Surfaces single points of failure and missing error handling before production.
Organizations design systems that mirror their communication structure.
Flags service boundaries that conflict with how your teams actually work.
Adding manpower to a late software project makes it later.
Gives new engineers the team playbook through the agent from day one.
Pricing
Start free. Upgrade when you need more protocols, seats, or automation.
Free
Personal guardrails and local enforcement.
$19/mo
For engineers who live in AI-assisted IDEs.
$79/mo
Shared standards across the engineering org.
Custom
Security, scale, and dedicated deployments.
Roadmap
FAQ
A platform that turns engineering standards into active protocols and injects them into AI agents via MCP, so generated code follows your team’s rules.
Linters check code after it exists, mostly for syntax and style. DevLaws supplies architectural and process context while the agent is writing, so problems are less likely to be introduced in the first place.
Static files are per-tool and go out of date. DevLaws is a shared, updatable protocol that can apply across agents at once, with team sync and central management.
Tools that support MCP or custom context — including Cursor, Claude Code, GitHub Copilot, Windsurf, Gemini CLI, and Codex-based workflows.
Yes. Team and Enterprise plans support shared protocols, folders, access control, and real-time sync when rules change.
Handbook
Full-text pages for search engines and readers — no app login required.
Connect your agents. Enforce once. Stay consistent.
Get started