Plain-English Lint Rules

Custom Lint Rules From Plain English

Say what the rule should catch. Taskless has your coding agent write it, proves it against pass and fail fixtures, and hands it to an engine that decides it deterministically. The rule runs the same way for every developer and every agent, with no model in the loop.

Read the docs

Open source CLI. Runs locally, no account required.

Describe it, get a rule

Custom lint rules are worth having and tedious to write. Each linter has its own rule API, its own AST, and its own test harness, so most team conventions never become rules at all.

With Taskless you write the sentence instead. Your coding agent reads the codebase, writes the rule, and writes fixtures: code the rule must flag and code it must leave alone. The rule is not done until both pass.

> Create a taskless rule that catches direct fetch() calls
> without error handling. Allow them inside src/lib/http/.

Taskless picks what enforces it

You do not choose a tool. Taskless routes the rule by what evidence decides it:

  • Your existing linter, when it can express the rule. Taskless writes it into ESLint, Ruff, RuboCop, or Stylelint in that tool’s own dialect, and your lint step runs it.
  • ast-grep, when one file’s syntax tree decides it. Structural matching, not regex, across 25+ languages.
  • Vale, when the words decide it: docs, READMEs, comments, and the prose parts of code.
  • A runtime rule, when the evidence spans files or lives outside them. Runtime rules require Taskless Cloud, because they execute code and Taskless signs it.

Every rule proves itself

Each rule lives in its own directory with tests/fail and tests/pass cases. taskless verify runs them, so a rule that misses what you meant, or flags what you did not, fails before it touches your code. When a rule needs to change, ask your agent to improve it and add the case that was wrong as a new fixture.

No model when the rule runs

A model helps write the rule. It does not run it. taskless check runs ast-grep, Vale, and runtime rules, reports file, line, severity, and message, and exits non-zero on an error. Same input, same result, every run.

That is the difference from asking a review bot to apply your conventions: the bot is a model reading your instructions, and the rule is a check.

Built for code your agent writes

Code written by coding agents breaks conventions in ways a generic linter config does not cover, because the conventions are yours. Taskless installs as a skill for Claude Code, Cursor, and OpenCode, so the agent can run the checks itself and fix what they find before it opens a pull request.

Frequently Asked Questions

Can a coding agent write ESLint rules from a description?
Yes. When ESLint can express the rule, Taskless writes it into your ESLint configuration and your lint step enforces it. The same goes for Ruff, RuboCop, and Stylelint. taskless check does not run those linters; your existing setup does.
Which languages are supported?
ast-grep rules cover 25+ programming languages, and Vale rules cover prose in Markdown, docs, and comments. The Taskless docs list every supported language and file format.
Do I need an account?
No. Linter, ast-grep, and Vale rules are available in the Taskless Open Source CLI and run locally with no account and no network call. Runtime rules and service-generated rules require Taskless Cloud.
What happens when a rule flags the wrong thing?
Ask your agent to improve the rule and give it the case that was wrong. It adds that case as a fixture, revises the rule until every fixture passes, and the false positive cannot come back unnoticed.

Write the rule once. Check it every run.

Install the CLI, then ask your agent to onboard the project. It reads your codebase and history and writes the rules it can enforce locally.

Explore Cloud →