Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.codeant.ai/llms.txt

Use this file to discover all available pages before exploring further.

Integrate CodeAnt AI into Cursor to resolve PR review comments, review local changes, and generate custom review rules — driven by Cursor’s AI agent.

​
What You Get

Four Cursor Skills that teach the AI agent how to use the CodeAnt CLI:
Slash CommandDescription
/codeant-reviewRun a CodeAnt code review on local changes and fix all issues
/codeant-resolve-pr-commentsFetch unresolved CodeAnt review comments on a PR and fix them
/codeant-resolve-quality-gatesParse the CodeAnt CI/CD Quality Gate comment on a PR and fix the SAST, Secrets, and Duplicate Code findings
/codeant-implement-repo-learningsLearn team review patterns from PR history and generate custom rules

​
Prerequisites

  1. Cursor 2.4 or later — the new Skills system requires this minimum version (download)
  2. CodeAnt CLI installed and authenticated — follow the CLI setup guide

​
Installation

Run these commands from your project root: 
mkdir -p .cursor/skills
git clone https://github.com/CodeAnt-AI/skills.git /tmp/codeant-skills
cp -r /tmp/codeant-skills/cursor/skills/* .cursor/skills/
rm -rf /tmp/codeant-skills
Commit to share with your team: 
git add .cursor/skills/
git commit -m "Add CodeAnt AI Cursor skills"

​
Option 2: Create Manually

Create the skill files under .cursor/skills/ — see the full skill content in the skills repository. Each skill is a SKILL.md file inside its own directory: 
.cursor/skills/
├── codeant-review/SKILL.md
├── codeant-resolve-pr-comments/SKILL.md
├── codeant-resolve-quality-gates/SKILL.md
└── codeant-implement-repo-learnings/SKILL.md
If you previously installed the .mdc rule file to .cursor/rules/codeant.mdc, you can migrate to the new Skills format:
  1. Install the new skills using the instructions above
  2. Delete the old rule file: rm .cursor/rules/codeant.mdc
  3. Restart Cursor
The new Skills format provides slash command invocation, better discoverability, and feature parity with the Claude Code integration.

​
Usage

​
/codeant-resolve-pr-comments — Resolve PR Review Comments

Fetch all unresolved CodeAnt AI review comments on a pull request and fix them. With a PR number: 
> /codeant-resolve-pr-comments 42
Auto-detect from current branch: 
> /codeant-resolve-pr-comments
Or use natural language: 
> Fix all unresolved CodeAnt comments on my current PR
The fix flow:
  1. Find the PR — detects from current branch or uses the provided PR number
  2. Fetch comments — runs codeant pr comments --pr-number <N> --codeant-generated true and filters to unresolved comments
  3. Categorize — separates inline code comments (actionable) from general PR-level comments (informational, skipped)
  4. Analyze and assign verdicts — for each comment:
    • Reads the file with 30 lines of surrounding context
    • Checks the code still matches what the comment describes
    • Extracts code suggestions from the comment body
    • Validates syntax, variable scope, imports, and that existing logic is not broken
    • Assigns a verdict: ACCEPT, LIKELY ACCEPT, DO NOT ACCEPT, or STALE
  5. Present summary — shows all comments grouped by verdict with before/after code diffs
  6. Apply safe fixes — applies ACCEPT fixes, asks about LIKELY ACCEPT, skips DO NOT ACCEPT and STALE
  7. Resolve threads — marks applied comments as resolved on the PR via codeant pr resolve
  8. Offer to commit — lists changed files and offers to commit and push
Changes are not committed automatically — you review the diffs and decide.

​
/codeant-resolve-quality-gates — Fix CI/CD Quality Gate Failures

Locate the CodeAnt Quality Gate comment posted by CI on the current branch’s PR and fix the listed findings. With a PR number: 
> /codeant-resolve-quality-gates 42
Auto-detect from current branch: 
> /codeant-resolve-quality-gates
Or use natural language: 
> Fix the quality gate failures on my PR
The fix flow:
  1. Find the PR — detects from current branch or uses the provided PR number
  2. Locate the comment — fetches CodeAnt comments and picks the most recent one whose body starts with CodeAnt Quality Gate Results
  3. Parse failures — extracts the list of failed gates from the summary table and the per-finding rows from the View Failure Result block (SAST, Secrets, Duplicate Code)
  4. Analyze and assign verdicts — for each finding:
    • Reads the file at the indicated line with 30 lines of context
    • Drafts a minimal fix (the comment contains no inline suggestion — the skill designs the fix from the rule / type / window)
    • Validates syntax, scope, error handling, and that existing behavior is preserved
    • Assigns a verdict: ACCEPT, LIKELY ACCEPT, DO NOT ACCEPT, or STALE
  5. Present summary — groups findings by verdict and gate type, shows before/after diffs
  6. Apply safe fixes — ACCEPT automatically, LIKELY ACCEPT with confirmation, skip the rest
  7. Offer to commit — pushing the fix commit re-triggers CI, which updates the quality gate comment
Coverage by gate:
GateRow-level details in the comment?What the skill does
SASTYes — Severity, File, Line, Rule, MessageParses and drafts fixes
SecretsYes — File, Line, Type, ConfidenceReplaces literal with env var; reminds you to rotate
Duplicate CodeYes — file ↔ file groupsUsually DO NOT ACCEPT unless extraction is tiny and obvious
SCA (Dependencies)No — only aggregated countsOffers to run codeant security-analysis --uncommitted
IACNo — only aggregated countsPoints to the dashboard’s View Full Results link
Changes are not committed automatically — you review the diffs and decide.

​
/codeant-review — Review and Fix Local Changes

Run a CodeAnt AI code review on your local changes and fix all issues found. 
> /codeant-review
You can specify the review scope: 
> /codeant-review staged files only
> /codeant-review last commit
> /codeant-review against the develop branch
The skill selects the right flag based on your request:
You sayFlag used
”staged”--staged
”uncommitted” / nothing specific--uncommitted (default)
“last commit”--last-commit
”last 3 commits”--last-n-commits 3
”unpushed” / “committed”--committed
a branch name--base <branch>
a commit hash--base-commit <hash>
”everything” / “all”--all
The fix flow:
  1. Run review — executes codeant review <scope-flag>
  2. Present findings — shows issues grouped by file with category labels (Security, Code Quality, Performance, Maintainability)
  3. Analyze and assign verdicts — classifies each issue as ACCEPT, LIKELY ACCEPT, DO NOT ACCEPT, or STALE
  4. Present summary with verdicts — shows before/after code diffs, highlights Security issues first
  5. Apply safe fixes — minimal changes only, skips anything that could break existing logic
  6. Verify — re-runs the review to confirm fixes are clean
  7. Report — initial findings, fixes applied, fixes skipped (and why), and verification results
Changes are not committed automatically — you review the diffs and commit when ready.

​
/codeant-implement-repo-learnings — Generate Custom Review Rules

Analyze your team’s PR review history to generate custom CodeAnt review rules. 
> /codeant-implement-repo-learnings
The workflow:
  1. Fetch PR history — retrieves the last 100 merged PRs
  2. Extract human feedback — fetches review comments, filters out bots and non-actionable replies
  3. Analyze bug-fix commits — mines git history for recurring fix patterns
  4. Read project guidelines — extracts conventions from .cursorrules, CLAUDE.md, CONTRIBUTING.md, etc.
  5. Cluster patterns — groups feedback into rule candidates with confidence levels (HIGH/MEDIUM)
  6. Interactive confirmation — presents each rule with evidence for your approval
  7. Write rules — generates .codeant/review.json with your approved rules
Rules are merged with any existing .codeant/review.json — nothing is overwritten without confirmation.

​
Verdict System

All fix workflows use a verdict system to classify each suggestion before applying:
VerdictMeaningAction
ACCEPTSafe to apply — fix is correct, localized, and won’t break anythingApplied automatically
LIKELY ACCEPTProbably correct, but may affect callers or testsApplied only with user confirmation
DO NOT ACCEPTCould break logic — changes signatures, removes error handling, or over-refactorsSkipped with explanation
STALECode has changed since the review — comment no longer appliesSkipped with explanation

​
Example Workflows

​
Resolve PR Comments

> /codeant-resolve-pr-comments

Found PR #42: "Add payment processing" (feature/payments → main)

6 unresolved CodeAnt comments:

ACCEPT — Safe to apply (3):
  src/auth.ts:34 — SQL injection in login query
    Fix: parameterize the query → safe, no API change
  src/auth.ts:78 — Missing rate limiting
    Fix: add rate limiting middleware → safe, additive only
  src/api/users.ts:45 — Magic number should be a constant
    Fix: extract to named constant → safe, no behavior change

LIKELY ACCEPT — Verify callers (1):
  src/api/users.ts:12 — Unvalidated input
    Fix: add validation → callers may depend on permissive behavior

DO NOT ACCEPT (0)
STALE (0)

Manual review needed (2):
  PR-level comments about error handling strategy and test coverage

I will apply the 3 ACCEPT fixes now. Want me to also apply
the LIKELY ACCEPT fix, or skip it for now?

> apply all

✓ Applied src/auth.ts:34 — parameterized the SQL query
✓ Applied src/auth.ts:78 — added rate limiting middleware
✓ Applied src/api/users.ts:45 — extracted magic number to constant
✓ Applied src/api/users.ts:12 — added input validation

Resolving applied comments on PR...
✓ 4 comments resolved

Changes ready for review. Would you like me to commit and push?

​
Review → Fix → Ship

> Implement the user authentication endpoint

(Cursor implements the feature)

> /codeant-review

Found 3 issues:
  Security: Missing input sanitization (src/auth.ts:15)   — ACCEPT
  Code Quality: Unused variable (src/auth.ts:8)            — ACCEPT
  Code Quality: Missing error handling (src/auth.ts:42)    — ACCEPT

All 3 fixes applied. Verification passed — no remaining issues.

> git add -A && git commit -m "Add auth endpoint"

​
How It Works

Each skill is a SKILL.md file inside .cursor/skills/ — part of Cursor’s Agent Skills system. Skills teach the Cursor agent specialized workflows through detailed step-by-step instructions. Skills are automatically discovered by Cursor and can be invoked via /skill-name slash commands or triggered automatically when the agent determines they’re relevant. You can also reference them naturally in conversation (e.g., “review my changes with CodeAnt”).

​
Troubleshooting

“codeant: command not found” Ensure the CLI is installed globally and accessible from Cursor’s terminal: 
npm install -g codeant-cli
codeant --version
If using nvm, ensure the correct Node version is active in Cursor’s integrated terminal. “Not authenticated” or “Could not detect remote” 
codeant login                           # CodeAnt API auth
codeant set-token github <your-token>   # SCM auth for PR features
Skills not appearing
  • Verify .cursor/skills/codeant-review/SKILL.md exists (and similar for other skills)
  • Restart Cursor after adding skills
  • Check Settings → Rules to see if skills appear under “Agent Decides”
  • Be explicit: “Use CodeAnt to review my changes” or use /codeant-review