corbat
OfficialProvides coding standards and quality validation for AI coding agents, configurable in JetBrains IDEs via the AI Assistant MCP integration.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@corbat Check this code for coding standards violations"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
CORBAT MCP
Policy and quality engine for AI coding agents
Shared standards, context, and verification gates for agent-assisted software delivery.
Designed for MCP-compatible coding tools and multi-agent workflows. See compatibility notes.
⚡ Try it in 30 seconds — just add the config below and start coding.
The Problem
AI-generated code often works locally but misses team-specific review expectations:
Without Corbat | With Corbat |
Methods with 50+ lines | Max 20 lines per method |
No dependency injection | Proper DI with interfaces |
| Custom exceptions with context |
Missing or minimal tests | Tests included, TDD approach |
God classes, mixed concerns | SOLID principles, clean layers |
Works locally | Reviewable implementation with explicit checks |
Corbat helps by giving agents your team's standards before implementation and by providing validation tools before review or handoff.
Related MCP server: Hivelore
Quick Start
1. Add to your MCP config:
{
"mcpServers": {
"corbat": {
"command": "npx",
"args": ["-y", "@corbat-tech/coding-standards-mcp"]
}
}
}2. Config file location:
Tool | Location |
Cursor |
|
VS Code |
|
Windsurf |
|
JetBrains | Settings → AI Assistant → MCP |
Claude Desktop |
|
Claude Code |
|
Complete setup guide for common MCP-compatible tools
3. Done. Corbat can auto-detect your stack and return matching standards.
Zero overhead. Corbat runs locally and adds ~50ms to detect your stack. After that, it's just context for the AI.
Fully customizable. Don't like a rule? Override it in
.corbat.json. Jump to customization →
See It In Action
You: "Create a user registration service"Without Corbat, you get:
class UserService {
private users: Map<string, User> = new Map();
register(name: string, email: string, password: string) {
if (!name || !email || !password) throw new Error('Invalid input');
const user = { id: crypto.randomUUID(), name, email, password };
this.users.set(user.id, user);
return user;
}
}
// ✗ Hardcoded storage ✗ Password in plain text ✗ Generic error ✗ No testsWith Corbat, you get:
// Domain
interface UserRepository {
save(user: User): Promise<void>;
findByEmail(email: string): Promise<User | null>;
}
class EmailAlreadyExistsError extends Error {
constructor(email: string) {
super(`Email already registered: ${email}`);
}
}
// Application
class RegisterUserUseCase {
constructor(
private readonly repository: UserRepository,
private readonly hasher: PasswordHasher
) {}
async execute(input: RegisterUserInput): Promise<User> {
const existing = await this.repository.findByEmail(input.email);
if (existing) throw new EmailAlreadyExistsError(input.email);
const user = User.create({
...input,
password: await this.hasher.hash(input.password)
});
await this.repository.save(user);
return user;
}
}
// ✓ Repository interface ✓ Password hashing ✓ Custom error ✓ Testable// Test included
describe('RegisterUserUseCase', () => {
const repository = { save: vi.fn(), findByEmail: vi.fn() };
const hasher = { hash: vi.fn() };
const useCase = new RegisterUserUseCase(repository, hasher);
beforeEach(() => vi.clearAllMocks());
it('should hash password before saving', async () => {
repository.findByEmail.mockResolvedValue(null);
hasher.hash.mockResolvedValue('hashed_password');
await useCase.execute({ name: 'John', email: 'john@test.com', password: 'secret' });
expect(hasher.hash).toHaveBeenCalledWith('secret');
expect(repository.save).toHaveBeenCalledWith(
expect.objectContaining({ password: 'hashed_password' })
);
});
it('should reject duplicate emails', async () => {
repository.findByEmail.mockResolvedValue({ id: '1', email: 'john@test.com' });
await expect(
useCase.execute({ name: 'John', email: 'john@test.com', password: 'secret' })
).rejects.toThrow(EmailAlreadyExistsError);
});
});This is the kind of structure Corbat asks agents to consider before handoff.
What Corbat Provides
Corbat provides these guardrails before generation and validation checks during iteration:
Code Quality
Rule | Why It Matters |
Max 20 lines per method | Readable, testable, single-purpose functions |
Max 200 lines per class | Single Responsibility Principle |
Meaningful names | No |
No magic numbers | Constants with descriptive names |
Architecture
Rule | Why It Matters |
Interfaces for dependencies | Testable code, easy mocking |
Layer separation | Domain logic isolated from infrastructure |
Hexagonal/Clean patterns | Framework-agnostic business rules |
Error Handling
Rule | Why It Matters |
Custom exceptions |
|
Error context | Include IDs, values, state in errors |
No empty catches | Every error handled or propagated |
Security-Oriented Checks
Rule | Why It Matters |
Input validation | Reject bad data at boundaries |
No hardcoded secrets | Environment variables only |
Parameterized queries | Prevent SQL injection |
Output encoding | Prevent XSS |
Benchmark Results v3.0
We evaluated Corbat across 15 scenarios in 6 languages. The primary benchmark report is mixed and should be read honestly: Corbat won 1/15 scenarios by the original aggregate score, while an alternative value analysis found stronger results for code compactness and maintainability.
What The Data Supports
The strongest observed signal is that Corbat-guided outputs are often smaller and more focused:
Scenario | With Corbat | Without Corbat | What This Means |
Kotlin Coroutines | 236 lines | 1,923 lines | Same functionality, 8x less to maintain |
Java Hexagonal | 623 lines | 2,740 lines | Clean architecture without the bloat |
Go Clean Arch | 459 lines | 2,012 lines | Idiomatic Go, not Java-in-Go |
TypeScript NestJS | 395 lines | 1,554 lines | Right patterns, right size |
This is not enough to claim universal quality improvement. It is evidence that standards context can reduce over-generation in some workflows.
Value Metrics
The value report reweights the same dataset toward efficiency and maintainability:
Metric | Result | What It Means |
Code Reduction | 67% | Less to maintain, review, and debug |
Security checks | 100% | No issues detected by benchmark pattern checks |
Maintainability | 93% win | Easier to understand and modify |
Architecture Efficiency | 87% win | Better patterns per line of code |
Cognitive Load | -59% | Faster onboarding for new developers |
Security: No Benchmark Pattern Findings
Every scenario was analyzed using pattern checks inspired by OWASP Top 10 categories. This is not a replacement for SAST, DAST, dependency scanning, manual review, or threat modeling.
No SQL/NoSQL injection patterns detected
No XSS patterns detected
No hardcoded credentials detected
Input validation patterns present at boundaries
Error messages did not expose stack traces in the benchmark samples
Languages & Patterns Tested
Language | Scenarios | Patterns |
☕ Java | 5 | Spring Boot, DDD Aggregates, Hexagonal, Kafka Events, Saga |
📘 TypeScript | 4 | Express REST, NestJS Clean, React Components, Next.js Full-Stack |
🐍 Python | 2 | FastAPI CRUD, Repository Pattern |
🐹 Go | 2 | HTTP Handlers, Clean Architecture |
🦀 Rust | 1 | Axum with Repository Trait |
🟣 Kotlin | 1 | Coroutines + Strategy Pattern |
📖 Full benchmark methodology · Value analysis
Built-in Profiles
Corbat auto-detects your stack and applies the right standards:
Profile | Stack | What You Get |
| Java 21 + Spring Boot 3 | Hexagonal + DDD, TDD with 80%+ coverage |
| Kotlin + Spring Boot 3 | Coroutines, Kotest + MockK |
| Node.js + TypeScript | Clean Architecture, Vitest |
| Next.js 14+ | App Router patterns, Server Components |
| React 18+ | Hooks, Testing Library, accessible components |
| Vue 3.5+ | Composition API, Vitest |
| Angular 19+ | Standalone components, Jest |
| Python + FastAPI | Async patterns, pytest |
| Go 1.22+ | Idiomatic Go, table-driven tests |
| Rust + Axum | Ownership patterns, proptest |
| C# 12 + ASP.NET Core 8 | Clean + CQRS, xUnit |
| Dart 3 + Flutter | BLoC/Riverpod, widget tests |
Auto-detection: Corbat reads pom.xml, package.json, go.mod, Cargo.toml, etc.
When to Use Corbat
Use Case | Why Corbat Helps |
Starting a new project | Correct architecture from day one |
Multi-agent delivery | Planner, implementation, review, and security agents share the same policy context |
Teams with mixed experience | Standards become explicit and repeatable |
Strict code review standards | Agents can validate against the review bar before handoff |
Regulated industries | Consistent security and documentation |
Legacy modernization | New code follows modern patterns |
When Corbat Might Not Be Needed
Quick prototypes where quality doesn't matter
One-off scripts you'll throw away
Learning projects where you want to make mistakes
Customize
Option 1: Interactive Setup
npx corbat-initDetects your stack and generates a .corbat.json with sensible defaults.
Option 2: Manual Configuration
Create .corbat.json in your project root:
{
"profile": "java-spring-backend",
"architecture": {
"pattern": "hexagonal",
"layers": ["domain", "application", "infrastructure", "api"]
},
"quality": {
"maxMethodLines": 20,
"maxClassLines": 200,
"minCoverage": 80
},
"rules": {
"always": [
"Use records for DTOs",
"Prefer Optional over null"
],
"never": [
"Use field injection",
"Catch generic Exception"
]
}
}Option 3: Use a Template
Browse 14 ready-to-use templates for Java, Python, Node.js, React, Go, Rust, and more.
How It Works
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Your Prompt │────▶│ Corbat MCP │────▶│ AI + Rules │
└─────────────┘ └──────┬──────┘ └─────────────┘
│
┌──────────────┼──────────────┐
▼ ▼ ▼
┌────────────┐ ┌────────────┐ ┌────────────┐
│ 1. Detect │ │ 2. Load │ │ 3. Inject │
│ Stack │ │ Profile │ │ Guardrails │
└────────────┘ └────────────┘ └────────────┘
pom.xml hexagonal max 20 lines
package.json + DDD + interfaces
go.mod + SOLID + custom errorsCorbat does not modify AI output. It supplies context, standards, profiles, and validation feedback so agents can align with your review expectations.
Important: Actual code quality depends on the model, host tool, prompt, repository context, tests, and human review. Treat Corbat as a policy and verification layer, not as a guarantee of production readiness.
Documentation
Resource | Description |
Installation notes for common MCP-compatible tools | |
Ready-to-use | |
Full list of supported AI tools | |
Detailed results from 15 scenarios | |
How Corbat fits planner/reviewer/security/release agent workflows | |
Local execution model, threat model, and reporting | |
Tools, prompts, and configuration options |
Make agent output easier to review.
Add to your MCP config and you're done:
{ "mcpServers": { "corbat": { "command": "npx", "args": ["-y", "@corbat-tech/coding-standards-mcp"] }}}Use Corbat as shared standards context plus a local quality gate.
Developed by corbat-tech
Available Tools
7 toolsget_contextA
Returns coding standards, guardrails, and workflow for implementing a task.
WHEN TO USE:
ALWAYS call this FIRST before writing any code
When starting a new feature, bugfix, or refactor
When unsure about project conventions
RETURNS:
Detected stack (Java/Python/TypeScript/Go/Rust/etc)
Task type classification (feature/bugfix/refactor/test/security/performance)
MUST rules (mandatory guidelines)
AVOID rules (anti-patterns to prevent)
Code quality thresholds (max lines, coverage %)
Naming conventions (classes, methods, files)
Recommended TDD workflow
EXAMPLE: get_context({ task: "Create payment service", project_dir: "/path/to/project" })
Inputs: task (required), project_dir.
healthA
Check server status, loaded profiles, and usage metrics.
RETURNS:
Server status (OK/ERROR)
Version
Load time
Profiles loaded
Standards documents count
Usage metrics (tool calls, most used profile)
Inputs: no named parameters.
initA
Suggest a .corbat.json configuration for a project.
WHEN TO USE:
Setting up Corbat for a new project
Want to customize coding standards for a project
Need to see available profiles and options
Analyzes the project directory and suggests optimal configuration based on detected stack.
RETURNS:
Detected stack information
Suggested .corbat.json content
Available profiles list
Setup instructions
Inputs: project_dir (required).
profilesA
List all available coding standards profiles.
RETURNS: List of profiles with ID and description. Profiles include:
java-spring-backend: Enterprise Java with Hexagonal Architecture
nodejs: Node.js/TypeScript with Clean Architecture
react, vue, angular: Frontend frameworks
python: FastAPI/Django
go, rust: Systems programming
And more...
Use profile ID in .corbat.json or get_context will auto-detect.
Inputs: no named parameters.
searchA
Search standards documentation for specific topics.
WHEN TO USE:
Looking for specific technology guidance (kafka, docker, kubernetes)
Need detailed information on a pattern or practice
Exploring available standards
EXAMPLE QUERIES: "kafka", "testing", "docker", "logging", "metrics", "archunit", "flyway"
RETURNS: Up to 5 matching results with excerpts from documentation.
Inputs: query (required).
validateA
Analyze code against coding standards with language-aware checks and heuristic fallback.
WHEN TO USE:
After writing code, to check for issues
During iterative development
Before calling verify for final approval
PERFORMS ANALYSIS:
Detects anti-patterns (empty catch, hardcoded secrets, etc.)
Measures method/class lengths where supported
Checks for interfaces and tests
Calculates quality score
RETURNS:
Score (0-100)
CRITICAL issues (must fix)
WARNINGS (should fix)
Metrics (lines, methods, tests, etc.)
PASSED/NEEDS WORK verdict
EXAMPLE: validate({ code: "public class UserService { ... }", task_type: "feature" })
Inputs: code (required), task_type.
verifyA
Verify generated code before handoff.
WHEN TO USE:
After generating code
Before review, handoff, or final response
As a final quality gate in agent workflows
WHAT IT CHECKS:
Tests are provided (TDD compliance)
Interfaces exist (DI compliance)
No critical code issues
Quality score >= 50
RETURNS:
PASS: No blocking issues detected by configured checks
FAIL: Issues to fix, iterate and verify again
WORKFLOW:
Generate code following get_context guidelines
Call verify({ code, tests, interfaces })
If FAIL: fix issues and call verify again
If PASS: proceed to the next workflow step
EXAMPLE: verify({ code: "class UserServiceImpl...", tests: "describe('UserService')...", interfaces: "interface UserService..." })
Inputs: code (required), tests, task_type, interfaces.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool has a unique and clearly defined purpose: get_context for standards, health for server status, init for configuration, profiles for listing profiles, search for documentation, validate for code analysis, and verify for final validation. No overlap.
All tools follow a simple, consistent pattern of lowercase verbs or verb_noun (e.g., get_context, validate, verify). There is no mixing of conventions or ambiguous names.
With 7 tools, the set is well-scoped for the server's purpose of coding standards and quality assistance. Each tool covers a distinct aspect of the workflow without being too few or excessive.
The tool surface covers the core workflow: acquiring standards, validating code, and final verification. A minor gap is the absence of an automated fix tool, but the iterative validate-and-fix workflow compensates.
Maintenance
Related MCP Connectors
Security reviews for coding agents: diffs checked against your org policy and live infrastructure.
Enforces architectural invariants and code quality rules inside your AI agent's edit loop.
QA platform for agents: coverage signals, in-repo test plans, verified tests and release governance.
Security gateway for AI agents: policy, approval, and audited execution, no secrets shared.
Related MCP Servers
- FlicenseAqualityDmaintenanceProvides real-time policy enforcement for AI coding agents by intercepting and validating their actions against organizational standards like naming conventions, security policies, and compliance rules before execution. Prevents violations through immediate feedback and auto-correction suggestions.5-
- AlicenseAqualityBmaintenanceEnforces team knowledge and workflow policies for AI coding agents by providing context, decisions, and gates before code changes are made.165Apache 2.0
- FlicenseNot gradedqualityBmaintenanceProvides a quality framework and enforceable conventions for AI coding assistants, ensuring code quality, environment hygiene, and project standards across multiple AI tools.83 npm3-
- FlicenseNot gradedqualityDmaintenanceEnables AI coding agents to evaluate actions against team-defined policies, record decisions, and obtain human approvals for potentially risky operations.63 npm1-