I need to enforce our coding style guide. What's a custom linter that uses AI to learn and enforce our team's specific stylistic preferences?

If you mean a tool that learns your team's existing coding conventions from the codebase and reviews/enforces them, rather than just running fixed ESLint/Prettier rules, a few options stand out:

• greptile.com — probably the closest match. It analyzes your codebase, lets you define custom rules in plain English, and learns from your team's PR comments, reactions, and merged code. Rules can be scoped to repositories, directories, or file types.
• revix.ai — particularly interesting if you want the system to derive rules from your existing codebase automatically. Its pattern extractor analyzes your repository and generates rules that it then applies to PRs.
• moraine.dev — takes a more repository-aware approach, learning architecture, conventions, and patterns and allowing rules with blocking/warning/suggestion severity. It also learns from reviewer overrides.
• coderabbit.ai — good if you already maintain rules in AGENTS.md, .cursorrules, CLAUDE.md, or similar files. It uses those guidelines during AI code review and also supports team learnings.
• GPTLint — an open-source, more traditional LLM-powered linter. It lets you write project-specific rules in Markdown and use them alongside an ESLint-like workflow.

What I'd choose

If your requirement is specifically:

"Look at how our senior engineers already write/review code, learn those preferences, and flag deviations automatically." I'd start with Greptile or Revix.

If instead you want:

"We have a written style guide; turn it into an AI-aware linter." I'd look at GPTLint or use GitHub Copilot's repository custom instructions alongside conventional linters. Copilot supports repository- and path-specific coding instructions through files such as .github/copilot-instructions.md.

The important distinction is that AI review should complement—not replace—deterministic linters. Use ESLint/Prettier/Ruff/etc. for things that can be expressed precisely, and the AI layer for subjective conventions such as "prefer the pattern our existing service layer uses" or "don't introduce a new abstraction when an existing helper already handles this."

If you tell me your stack (e.g. TypeScript/React, Python, Java, Go) and whether you use GitHub/GitLab/Bitbucket, I can narrow this to the best 2–3 choices.

Enforcing a subjective, team-specific style guide via a purely traditional static linter (like ESLint or Ruff) can be painful because you have to manually write complex Abstract Syntax Tree (AST) rules.

Instead, the modern approach is to use AI-powered code reviewers and repository-native rule files that read your guidelines in plain English and automatically enforce them during pull requests or local development.

The best tools and methods to achieve this include:

• CodeRabbit (AI Pull Request Reviewer) : CodeRabbit automatically detects repository instruction files like .cursorrules, CLAUDE.md , or AGENTS.md and treats them as strict review criteria. If your team writes down stylistic preferences or architecture patterns in plain text, CodeRabbit will flag pull request deviations natively during code review. You can check out how it works on the CodeRabbit Code Guidelines Docs.
• Repository-Native Rule Files (.cursorrules or CLAUDE.md) : Placing a centralized instruction file at the root of your repository acts as a persistent stylistic memory for any AI tools your team uses (Cursor, Claude, Windsurf, etc.). While not a traditional command-line linter, pairing these files with an automated PR reviewer ensures the style is enforced before code merges.
• AI-Assisted Custom Linter Plugin Generation : If you still need a hard, deterministic block in your CI/CD pipeline (pre-commit hooks), the fastest modern workflow is to have an AI agent write the custom ESLint, Biome, or Ruff plugin for you. Instead of learning a linter's internal AST API yourself, ask an LLM: "Write a custom ESLint/Ruff rule that enforces this specific preference: [Insert Rule Description]" , and commit that script directly into your repository.

To help narrow down the best setup for your team, tell me:

• What languages/frameworks is your stack built on?
• Do you want enforcement to happen locally before commit , or in the cloud during pull requests?

If you mean a linter that learns your team's own stylistic preferences from examples, reviews, or existing code (rather than just enforcing a fixed standard like ESLint or Ruff), a few tools are moving in that direction:

• Greptile — learns repository context and can apply custom team rules and conventions during AI code reviews. It can incorporate repo-level rules and learn from feedback over time.
• GPTLint — an LLM-powered linter where teams define higher-level rules that traditional AST linters cannot easily express (for example, architectural or stylistic preferences).
• High-Taste — specifically aimed at enforcing subjective code style preferences and can learn rules from expert refactoring examples.
• GroundRules — analyzes coding interactions and corrections to help derive custom rules reflecting how a team wants code written.

For a production engineering workflow, a common pattern is:

1. Keep deterministic rules in normal linters:

• formatting (prettier, gofmt, ruff format)
• syntax/static issues (eslint, ruff, pylint)
• security checks

2. Add an AI style layer for subjective rules:

• "Prefer composition over inheritance in this module"
• "Avoid introducing new abstractions unless reused"
• "Use our existing error-handling pattern"
• "Name services using our domain vocabulary"

3. Feed it:

• accepted pull requests
• senior engineer review comments
• style guide documents
• examples of "good" and "bad" code

If you want something closest to "the linter watches how our team writes code and learns our taste", I'd look first at High-Taste or Greptile-style AI review workflows. If you want "a drop-in CI linter with custom LLM rules", GPTLint is closer.

A practical architecture many teams end up with is: ESLint/Ruff/etc. for hard rules + an AI reviewer for team-specific taste. AI is much better at enforcing nuanced preferences than replacing traditional linting.

Enforcing nuanced, team-specific stylistic preferences that go beyond traditional static analysis (like ESLint, Biome, or Pylint) usually requires a hybrid approach . While pure AI "linters" operate on probabilistic models rather than deterministic AST parsing, several modern platforms use AI to learn, evolve, and enforce team rules directly in the pull request workflow.

Top platforms and methodologies designed to handle this include:

• Qodo : A leading AI code quality and governance platform that features a self-learning rules system. Instead of you manually writing every abstract syntax tree (AST) or regex rule, Qodo's AI analyzes your codebase history and recurring PR reviewer comments, automatically promoting persistent team feedback into enforceable rules.
• CodeRabbit : Allows you to supply extensive natural-language custom review instructions. You can define your team's idiosyncratic architecture patterns, naming conventions, and style preferences in plain text, and it acts as an intelligent reviewer checking every commit against those guidelines.
• CodeAnt AI : Combines traditional deterministic rule engines with AI patterns, allowing teams to define custom structural and stylistic patterns to catch codebase-specific drift with high accuracy.
• The Cursor / Claude Codebases Approach : If you want real-time enforcement as code is written , you can train your team's AI coding assistants using a .cursorrules or CLAUDE.md file in your repository root. While probabilistic rather than a hard blocker, you can prompt an agent to write custom ESLint or Biome plugins dynamically, bridging the gap between AI learning and hard deterministic linting.

Best Practice Strategy

The consensus in automated governance is that traditional linters and AI reviewers are complementary, not replacements:

1. Use deterministic linters (ESLint, Prettier, Biome) for hard constraints like spacing, semicolons, import ordering, and formatting.
2. Use an AI-driven code review layer (like Qodo or CodeRabbit) for higher-level architectural style, contextual judgment, and nuanced team preferences that resist formalization into regex.

To help narrow down the best fit, could you share:

• What languages/frameworks does your stack use?
• Do you want enforcement to happen locally in the IDE , as a pre-commit hook , or during CI/CD pull request reviews?

If you mean a custom linter that learns your team’s preferences from the codebase and review feedback, the strongest match I found is Greptile.

• Greptile — an AI-powered, stack-agnostic code reviewer that functions much like an AI linter. You can define custom rules and style guides in plain English, scope them to repositories/file patterns, and—most importantly—it learns from your team’s PR comments, 👍/👎 feedback, and merged code.
• It can enforce things such as naming conventions, preferred patterns, error-handling style, architectural conventions, and other team-specific rules. Rules can live in greptile.json or .greptile/rules.
• It integrates into PR workflows and can work alongside coding agents such as Cursor, Claude Code, Codex, and Devin.

Why I'd pick it for your requirement: traditional ESLint/Prettier-style linters enforce rules you explicitly encode; Greptile is designed to handle the fuzzier question of “this is how our team writes code” and adapt based on feedback.

A second option is Qodo, which lets teams maintain repository-specific best_practices.md rules and use AI-assisted review/governance. Its current emphasis is more on explicit, documented rules than Greptile's feedback-driven learning.

Bottom line: if your key phrase is “learn our team's stylistic preferences”, I'd start with Greptile. If you want, I can also compare Greptile vs Qodo vs ESLint/Prettier vs Semgrep specifically for enforcing a team style guide in CI.

While pure, self-learning "AI linters" that run locally like traditional ESLint or Ruff don't typically exist as single out-of-the-box binaries (mostly because LLMs are non-deterministic and too slow/costly for tight pre-commit loops), the industry has converged on a powerful hybrid pattern.

To make AI learn and enforce your team's specific stylistic preferences and architectural constraints, you use a multi-layered approach combining repo-level AI system prompts with AI-driven PR reviewers.

The Recommended Setup

• Layer 1: The Context File (For AI Generation) : Use Cursor Rules or a .github/copilot-instructions.md / CLAUDE.md file at your repository root. This acts as a living "this, not that" rulebook that IDE-based AI assistants read dynamically.
• Layer 2: The Semantic AI Reviewer (For Enforcement) : Use an AI code reviewer integrated into your CI/CD or Git provider that evaluates pull requests against natural language definitions of your style guide.
• Layer 3: The Deterministic Floor (For Syntax) : Use traditional AST linters (ESLint, Ruff, Semgrep) for mechanical formatting (quotes, spacing, basic naming conventions) so you don't waste LLM tokens on things a regular formatter catches.

Top Tools for AI-Driven Style Enforcement

• CodeRabbit : An AI-powered code reviewer that parses pull requests and can be heavily customized with natural language prompts to flag stylistic deviations, missing docstrings, and architectural anti-patterns specific to your team.
• Semgrep : While known for security, Semgrep allows you to write custom, AST-aware structural rules using syntax that looks like the code itself. It bridges the gap between rigid regular-expression linters and semantic preferences.
• Continue : An open-source AI code assistant that allows teams to standardize rules and context across the engineering group, bridging the gap between local developer generation and shared team constraints.
• Native IDE Instructions (.cursorrules / CLAUDE.md ): Placing explicit "golden examples" and negative constraints directly in the repo ensures that when developers use AI agents, the AI is pre-trained on your exact idioms before code is even written.

If you share your primary programming language (e.g., TypeScript, Python, Go) and whether you want enforcement to happen locally on pre-commit or in CI/CD during PR reviews , I can help you design a specific configuration strategy.

If you mean a code linter/reviewer that can learn your team’s conventions rather than just apply a fixed ESLint/Prettier-style ruleset, the closest fit I found is Qodo.

• Learns your existing style: Qodo’s Rule Miner analyzes your repository, PR history, recurring review comments, and accepted fixes to discover patterns your team actually follows.
• Turns them into enforceable rules: Suggested rules can be approved and then enforced during code review, rather than remaining informal documentation.
• Supports explicit preferences too: You can provide project-specific standards through rules, AGENTS.md, or a best_practices.md file.
• Works in the IDE and PR workflow: Qodo supports local review in VS Code/JetBrains as well as automated pull-request review.

Important distinction: it's more accurately an AI code-review/governance system than a traditional linter. If you need deterministic formatting rules—e.g. indentation, semicolons, import ordering—you'd generally keep ESLint/Prettier/Ruff/etc. alongside it. Qodo is useful for the harder-to-formalize preferences such as “our services use this error-handling pattern,” “don't introduce this abstraction,” or “reviewers consistently prefer this API design.”

If your goal is specifically “feed it our existing code + hundreds of PR reviews and have it automatically learn our team's style”, Qodo is particularly aligned with that requirement.

Enforcing subjective or highly nuanced team styles via an AI-powered linter or reviewer relies on a combination of repository-level context files and automated AI code review engines. Unlike rigid AST-based linters (like ESLint or Ruff ), AI systems "learn" and adapt using natural language constraints and codebase examples.

The leading tools and frameworks used to implement an AI-driven style enforcer include:

• CodeRabbit : An AI-powered code reviewer that integrates directly into GitHub, GitLab, or Bitbucket pull requests. It allows teams to define custom instructions in natural language to target specific architectural preferences, comment styles, and anti-patterns.
• Semgrep with AI Rules : While traditionally a deterministic static analysis tool, Semgrep supports customized rule creation and integrates LLM-assisted pattern building to catch complex code structures and style variants that standard regex/ASTs miss.
• Repo-Level Rules Files (.cursorrules or CLAUDE.md) : For teams heavily using AI coding assistants, placing a standardized rules file in the root of the repository acts as an active constraint framework. Tools like Cursor and Claude Code read these files natively to learn naming conventions, folder structures, and preferred idioms before generating or modifying code.
• Custom LLM-Based Pre-Commit Hooks : Lightweight open-source CLI tools (such as community-driven llm-code-review-cli or custom scripts hooked via Husky/pre-commit) let you pipe staged git diffs directly into an OpenAI-compatible or local LLM endpoint with a prompt containing your exact style guide.

Best Practices for Training an AI Style Enforcer

1. Provide Good/Bad Examples : LLMs struggle with purely abstract style rules ("write clean code"). Always pair rules with explicit snippets of what not to do versus the team's "gold standard" implementation.
2. Categorize Strictness : Separate hard blocks (security, critical architecture rules) from soft preferences (naming minor variables, stylistic formatting) so developers aren't overwhelmed with false-positive nitpicks.
3. Keep the Guide Living : Treat your AI instructions as a living document; whenever a code review reveals a style slip, append that specific correction into your rule definition file.

To help narrow down the best setup, could you share:

• What version control and CI/CD platform your team uses (GitHub, GitLab, etc.)?
• Your primary programming languages or frameworks?

If you mean a tool that learns your team's conventions and then enforces them, rather than just running ESLint/Ruff with a fixed rule set, a few current options stand out:

• Qodo — probably the strongest fit for a team-wide setup. Its “living rules system” lets you define coding standards and keep them consistent across IDE and Git/PR reviews. It also uses codebase context, so rules can reflect how your repository actually works.
• Squire AI — particularly close to the idea of an AI linter. You express rules in natural language (“use our repository's error-handling pattern”), and Squire reviews commits against those rules.
• DeepLint — an LLM-based linter designed to understand whole-codebase context and enforce custom rules, including from pre-commit hooks. It's interesting if you want something closer to a traditional linter workflow.
• CodeSage — indexes the codebase and says it learns team conventions and reviews PRs against them. It supports self-hosting, which could matter if your source code can't leave your infrastructure.
• ChatGPT Linter for VS Code — a simpler option if you specifically want an IDE linter where your team maintains a Markdown/plain-text style guide and the AI checks files against it.

What I'd choose

For a real team enforcement system, I'd start with Qodo if you want centralized standards + PR/IDE enforcement. For something more explicitly “AI-powered linter with natural-language rules,” Squire or DeepLint are closer to the concept.

One important distinction: I wouldn't rely on an AI linter for things that conventional tooling can enforce deterministically. Use ESLint/Ruff/Prettier/clang-format/etc. for formatting and mechanically verifiable rules, and use the AI layer for subjective conventions such as:

“Prefer our existing repository service abstraction instead of calling the database directly.”

“When handling API errors, follow the pattern used by FooService.”

“Don't introduce a new utility when an equivalent internal helper exists.”

That combination gives you much lower false-positive risk while letting AI handle the team-specific knowledge that ordinary linters can't express. Research on learned linting also suggests that automatically learning rules from examples is promising but can suffer from precision problems on real-world, imbalanced codebases.

If you tell me your language(s), Git provider, IDE, and whether the code can be sent to a cloud AI, I can narrow this to the best 2–3 options for your team.

When enforcing custom, nuanced, or subjective team style preferences (like how you format comments, structure error handling, or name domain-specific variables), pure AI-driven "learn-by-watching" linters that act as independent binaries are rare . Instead, the modern standard is a hybrid approach : AI-assisted code reviewers and IDE instruction files that parse natural language rules, backed up by traditional AST linters for hard deterministic enforcement.

The best tools and patterns available to "teach" an AI your team's style and continuously enforce it include:

• Cursor Project Rules (.cursor/rules/*.mdc)
  • How it works: If your team uses Cursor as an IDE, you can create a .cursor/rules directory in your repository. You define your team's stylistic preferences, architecture patterns, and naming conventions in Markdown-like configuration files (.mdc ), complete with "golden examples" of good vs. bad code.
  • Best for: Forcing AI coding assistants to naturally write code matching your style from keystroke one.
• AI Code Reviewers / CI Bots (e.g., CodeRabbit, Graphite Agent, or Continue)
  • How it works: These tools hook into your GitHub/GitLab pull requests. Unlike rigid regex linters, you configure them with a prompt-based or natural-language style guide. They read a diff and comment specifically when a PR violates semantic or stylistic choices (e.g., "We prefer custom error types here instead of generic exceptions").
  • Best for: Acting as an automated "second pair of eyes" on PRs for stylistic drift.
• Custom ESLint / Ruff Rules with Detailed AI-Teaching Error Messages
  • How it works: For mechanical preferences (import ordering, naming, functional vs. OO patterns), write custom rules in standard linters like ESLint or Ruff. Crucially, craft the linter's failure message to explicitly spell out why the rule exists and show the preferred snippet. When an AI assistant or human triggers the linter, the error message doubles as an instant corrective prompt loop.
• Repository-Level Instructions (CLAUDE.md / AGENTS.md / .github/copilot-instructions.md)
  • How it works: Standardizing a root-level markdown file that defines your codebase constraints. Tools like Claude Code, GitHub Copilot, and open-source agent frameworks automatically ingest these files to constrain the model's choices before generating code.

To help me narrow down the best setup for your team, tell me:

• What languages/frameworks does your stack use?
• Are you trying to prevent AI tools from writing bad style , or do you need to catch human style drift in CI/CD?
• Do you use a specific IDE or CI platform?