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.
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?
Which languages are supported?
Do I need an account?
What happens when a rule flags the wrong thing?
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.