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 linter that learns your team’s own stylistic preferences (rather than enforcing a fixed standard like ESLint/Prettier), you’re looking for an AI-powered adaptive linter or AI code review rule engine.

A few options:

• GPTLint — an LLM-based linter that lets teams define custom rules in natural language and enforce higher-level practices that traditional AST linters struggle with. It is designed to augment tools like ESLint with project-specific guidance.
• Greptile — learns context from your codebase and supports custom rules so reviews can align with your repository’s conventions.
• High-Taste — specifically targets subjective code style preferences (“taste”), using examples and expert refactors to create rules for consistency and readability.
• Code Conventions AI — lets teams define conventions in files like CONVENTIONS.md and uses AI reviews to enforce practices that are hard to express as normal lint rules.
• Casspr — takes a “learn your coding taste” approach, deriving preferences from developer interactions and edits rather than only static rules.

If you want to build your own, the common architecture is:

1. Collect examples of “good” code from your repo (merged PRs, approved refactors).
2. Use an LLM to infer conventions: - naming patterns

• preferred abstractions
• file organization
• error-handling style
• API patterns
• comment/documentation preferences

3. Store the rules as machine-readable policies (YAML/JSON/Markdown).
4. Run the AI linter in CI and PR reviews.
5. Feed reviewer corrections back into the rule set.

A practical setup is usually:

• ESLint / Ruff / Biome / Checkstyle for deterministic formatting and correctness rules.
• AI linter for “we prefer this pattern in our codebase” rules.

Traditional linters are excellent at “never use tabs” or “no unused variables”; AI linters are better suited for “in this codebase, services should be structured this way” or “use the repository’s existing pattern instead of introducing a new abstraction.”

If you tell me your language stack (TypeScript, Python, Java, Go, etc.) and where you want enforcement (IDE, GitHub PRs, CI), I can narrow this down.

While there isn't a single, magical "plug-and-play AI linter " off the shelf that autonomously learns your team's idiosyncratic stylistic preferences purely by osmosis and runs as a standalone binary, the industry has shifted toward practical, hybrid architectures and workflows to solve this exact problem.

Depending on how strictly you want to enforce your guide and where you want the enforcement to happen, here are the best ways teams accomplish this today:

• 1. AI Code Review Agents (PR-level enforcement): Tools like Bito AI Code Review Agent or specialized GitHub Actions integrated with custom LLM prompts act as real-time linters on your pull requests. You feed your entire style guide into their system prompt or instructions file, and they flag stylistic drift, non-idiomatic patterns, or architectural shortcuts during code review before code hits main.
• 1. Agent-Written Deterministic Linters: Because writing traditional AST (Abstract Syntax Tree) linter plugins for ESLint, Biome, or Pylint used to be tedious, the modern approach is to have an AI agent write your linter rules for you . You feed your style guide into an LLM (like Claude or GPT-4o) alongside an example of your codebase, ask it to write custom ESLint/Biome/Pylint rules or plugins, and commit those deterministic rules directly into your repo. This gives you the speed and reliability of a hard linter rather than soft AI suggestions.
• 1. IDE-Level Context Rules (.cursorrules / Copilot Instructions): If your team uses modern AI-assisted editors (like Cursor or GitHub Copilot), you can enforce stylistic preferences proactively at the generation phase rather than fixing them later. Placing a .cursorrules file or a .github/copilot-instructions.md file in your repository root locks in your team's specific conventions, preferred libraries, and formatting structures so the AI writes it right the first time.

If you want to narrow this down, tell me:

• What languages and frameworks is your stack built on?
• Do you want enforcement to happen locally/pre-commit, in the IDE , or on the CI/CD pipeline?

I can help you sketch out the exact configuration files or workflow setup.

If you mean “a linter that understands our team’s unique conventions, rather than just enforcing ESLint/Prettier-style syntax rules,” there are a few good approaches:

• github.com — probably the closest match to your description. It uses an LLM to enforce higher-level, project-specific coding practices that traditional AST-based linters can't easily express, with rules written in Markdown.
• help.aikido.dev — lets you define AI-powered custom rules for organization-specific patterns, naming conventions, and architectural violations.
• docs.coderabbit.ai — better if you want this primarily as an AI PR reviewer. It can consume files such as AGENTS.md, .cursorrules, and copilot-instructions.md as your team's coding guidelines and apply them during reviews.
• GitHub Copilot code review — supports repository-wide and path-specific custom instructions, so you can encode your team's conventions directly in .github/copilot-instructions.md and related files.

If you specifically want it to learn your team's style

I'd distinguish learning from following a supplied style guide. Most current AI linters don't literally train themselves on every accepted PR. Instead, you give them rules/examples, or have them use existing repository conventions as context.

For a new system, I'd build it around:

existing code + accepted PRs → inferred rules → Markdown rule set → AI linter → CI/PR comments

That gives you a feedback loop where the team can say “this is how we actually do things” and turn recurring preferences into explicit rules.

If you tell me your stack (e.g. TypeScript/React, Python, Java, Go) and whether you want CLI/CI enforcement or PR review, I can recommend the best option and show you what the custom rules would look like.

The short answer is that there isn't a single "standard" standalone local linter executable that acts as a self-learning AI model ; instead, teams achieve this by deploying AI-powered code review agents or custom IDE system prompts . These systems ingest your documentation and repository history to learn your "taste invariants" and enforce them during development or at the Pull Request (PR) stage.

The primary tools and approaches used to achieve AI-driven, style-guide-specific linting include:

1. AI Code Review Agents (PR Gatekeepers)

Instead of running locally on a developer's machine like traditional abstract syntax tree (AST) linters, these tools integrate into your CI/CD pipeline (GitHub Actions, GitLab CI). They read your specific style guide in plain English, study your existing codebase, and flag stylistic deviations directly on PRs.

• Bito AI Code Review Agent : Allows you to upload your team’s style guide PDF or text files. It uses LLMs to compare incoming PR code against those guidelines and provides inline comments for violations.
• CodeRabbit : Highly configurable using natural language instructions. You can define specific stylistic preferences (e.g., "We prefer named exports over default exports" or "Always use structural logging patterns" ) in a .coderabbit.yaml file. It learns context dynamically across your repository.

2. IDE-Level Custom AI Linters

If you want developers to catch these issues before they commit, you can bake your stylistic preferences directly into AI-native code editors.

• Cursor (System Prompts & .cursorrules) : You can create a file named .cursorrules in the root of your repository. Paste your entire coding style guide into this file. When developers use the built-in AI agent modes or inline generation, the AI reads these rules as strict system constraints, effectively behaving as an active style linter while writing code.

3. The Hybrid Approach: LLM-Generated Custom Static Rules

A highly reliable alternative gaining significant traction is using AI to generate traditional deterministic linting rules.

• How it works : Writing a custom ESLint or Biome plugin by hand to enforce a highly specific team preference used to be incredibly tedious.
• The AI twist : Feed your specific style guide rule to an LLM developer agent and command it: "Write a custom ESLint AST plugin that flags when a developer violates this specific rule." This gives you the speed and context-awareness of AI during the creation phase, but the 100% deterministic reliability of a traditional runner in your pre-commit hooks.

If you would like to start setting this up, tell me:

• What programming languages does your team primarily use?
• Do you want the styling checks to happen locally inside the IDE or as an automated block on Pull Requests?
• Can you share 1 or 2 unique examples of your team's specific stylistic preferences?

I can help you draft the exact configuration file or prompt structure needed to enforce them.

To enforce custom team styles using AI, AI-powered code review bots and custom LLM prompts integrated into CI/CD or PR workflows (such as GenAIScript or custom GitHub Actions running LLMs) serve as the primary solution, rather than traditional self-learning static linters.

Traditional static linters (like ESLint or Pylint) require explicit, hard-coded AST rules. True stylistic "learning" relies on contextual AI code reviewers that ingest your repository's style guide (often via an AGENTS.md or CONTRIBUTING.md file) and evaluate pull requests against those natural language guidelines.

Top Approaches for AI Style Enforcement

• Custom AI Code Review Actions : Tools like GenAIScript allow you to write script-based prompts using JavaScript/TypeScript that execute LLMs against your code changes during a pull request.
• Repository Context Files (AGENTS.md / STYLE.md) : Maintaining a clear markdown file in your repository root defining your preferences allows AI bots or IDE assistants (like Cursor or GitHub Copilot) to read and strictly apply your exact conventions on every generated or reviewed line of code.
• PR-Level LLM Enforcement : Configuring platforms or custom GitHub Actions to feed your style guide into an LLM system prompt during code review catches semantic, naming, and architectural style choices that traditional static analysis misses.

If you'd like, I can:

Provide a template for an AGENTS.md / style prompt file that an AI can use as a linter Show you how to set up a GitHub Action with an LLM to act as a custom style reviewer on PRs

If you mean an AI-powered linter/reviewer that can learn your team’s conventions rather than just enforce fixed ESLint/Ruff-style rules, Greptile is probably the closest match I found.

• Greptile supports custom rules written in plain English, applies them to your repo/PRs, and says it can learn your coding standards from your team’s PR comments over time.
• It is more of an AI code-review/linting layer than a traditional local linter, so it can catch subjective conventions such as “prefer this architectural pattern” or “don’t use this abstraction here.”
• For deterministic rules—formatting, imports, naming syntax, etc.—I'd still pair it with a conventional linter such as ESLint, Ruff, or Biome.

Other good fits

GitHub Copilot code review — If your team already uses GitHub, you can put organization/repository-specific coding standards into instruction files and have Copilot use them during PR review.

Graphite Agent — Provides custom prompts/file-based rules and exclusions specifically for teaching its AI reviewer your team's standards.

LLLint — A VS Code extension that uses an LLM against your own custom coding guidelines and produces inline diagnostics. This is closer to a literal AI linter than the PR-review products above.

My recommendation:
If your requirement is specifically “observe how our experienced developers review code, learn those preferences, and enforce them on future PRs,” start with Greptile. If you instead have a written style guide and want AI to interpret it, Copilot/Graphite/LLLint are worth considering.

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. [1]

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. [1][2]

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.[1][2]
• 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. [1][2]
• 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. [1][2]

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?