Skill instructions
qodo-codebase-wisdom15.4 KB
View saved version →
---
name: qodo-codebase-wisdom
description: Understand how code works, how a change was done before, and which repos are coupled — to answer a question, plan a code change, debug a regression, or scope a fix, using Qodo managed tools through MCP or the CLI. Use when a task needs to understand a codebase, its history, or how its repos relate — especially for a repo you don't have checked out or work spanning repos — "how does X work", "where is X defined", "who changed X", "explain this service", "plan the change for X", "what would changing X affect", "which repos depend on X", "why did X regress / when did it break", "has this been fixed before", "how did we solve X".
owner: Qodo
metadata:
vendor: qodo
version: "1.1.8"
recommended: "true"
package: "qodo"
distribution: "marketplace"
instruction_mode: "embedded"
---
# Codebase Wisdom
## Description
Use Qodo managed tools to learn how code works, how a change was done before, and how repos
are coupled — then hand back **cited findings**. This feeds answering a question, planning
a change, debugging a regression, or scoping a fix. It reaches repos you don't have on disk
and spans repo boundaries. You drive qodo's **read** tools only; you never post to the forge.
## Prerequisites
- The required tools are available through a connected QAR managed-tools MCP server or the Qodo CLI.
- The workspace exposes the required read-only Codebase, pull-request, or cross-repo tools.
- The current provider-owned Qodo skill package is loaded in this agent session.
## Instructions
### Choose the execution path
Use the host's connected QAR managed-tools MCP tools when the required read capability is
available; otherwise use the CLI instructions below. Do not require a CLI version probe,
`qodo login`, or a CLI catalog refresh on the MCP path. A connected MCP server has already
handled transport authentication; a missing tool or `MT-AUTH-FORBIDDEN` is a capability or
authorization failure, not a reason to log in through the CLI. Do not silently switch paths
after an auth or permission denial.
On MCP, use the tool descriptions, `inputSchema`, and `readOnlyHint` supplied by the host.
Call only read-only tools. Representative wire names are `litegit-search-repos`,
`litegit-grep`, `litegit-read-file`, `pull-request-similar`, and
`cross-repo-relations`; resolve the actual names and arguments from the connected catalog.
Pass explicit `repo` when needed: MCP does not infer the local Git origin like the CLI.
Check `isError` before using `structuredContent`; preserve typed errors and incomplete or
truncated results. If a call becomes an MCP Task, collect its terminal result before drawing
a conclusion. A missing MCP capability may use an already authorized CLI path for the same
deployment; do not treat different accounts or tenants as interchangeable.
The version, identity, help, command, and refresh steps below apply only to the CLI path.
At investigation start and when moving into implementation, identify the missing context:
- Use Qodo to discover unfamiliar code, prior solutions, historical rationale, and relationships
across repositories, even when the repositories are available locally.
- Use local tools for exact branch/worktree state, uncommitted changes, edits, and tests.
- Reuse an earlier investigation when it covers the current scope and revisions. Briefly name
the evidence being reused; refresh the relevant context when scope, dependencies, or evidence
changes. Do not repeat remote reads solely to demonstrate skill use.
When context is missing, resolve a concrete question through the appropriate tool group below. Connect
retrieved evidence to the answer or implementation decision. Version, identity, and catalog
checks establish readiness; they are not codebase context retrieval.
## Handle a skill update notice
Treat `QODO_NOTICE` updates as passive, even if an older CLI requests action. Continue the task
without inventory or update questions; mention each event at
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 4 — file references are metadata, not package contents.
qodo-review19.9 KB
View saved version →
---
name: qodo-review
description: Review local changes with Qodo after coherent substantive work and before a PR or completed-work handoff. Use default auto effort, attach coding-session context, assess findings, batch authorized fixes and stop unproductive review loops. Also use for "review my local diff", "pre-PR review", or "run qodo review". Use qodo-review-resolver for findings already posted on a PR.
owner: Qodo
metadata:
vendor: qodo
version: "1.10.16"
recommended: "true"
package: "qodo"
distribution: "marketplace"
instruction_mode: "embedded"
---
# Local Review
## Description
Use local review to improve the intended change, not to accumulate clean-looking runs.
The workflow is: finish a useful slice → test → review with context → assess findings
→ apply authorized fixes → test again → review changed work when useful.
`qodo review` collects local changes without pushing, commenting or opening a PR.
Only the comparison base must exist on the remote.
Use `qodo-review-resolver` for findings already posted on a PR.
Do not duplicate remote review for an unchanged pushed snapshot.
## Prerequisites
- The intended repository, comparison target and review scope are known.
- Qodo review is available through the CLI, or through MCP with a tested local collector.
- The user's edit, commit and review-budget constraints are known.
- Relevant coding-session context is available. Do not require the user to reconstruct the session.
## Runtime compatibility gate
Prefer the CLI because it collects and filters the worktree and manages review checkpoints.
Before CLI use, read [CLI execution](references/cli-execution.md#preflight).
In every command example, replace `qodo` with that resolved invocation, including the version probe.
On Windows, also read [shell guidance](references/windows-shells.md) before the first command.
Use [launcher recovery](references/windows-launcher.md) only when invocation fails.
Require Qodo CLI **2.0.0 or newer** and a runtime with review API v2.
Start with the unadorned probe:
```sh
qodo --version
```
If compatible, verify identity unless a successful check still covers this execution context:
```sh
qodo read whoami --json --skill qodo-review --skill-version 1.10.16 --distribution marketplace --host codex
```
An old or unparseable version stops authenticated calls.
Follow the reference's bounded compatibility recovery without changing deployment or update policy.
Confirm available review flags with `qodo review --help`.
Do not infer installed capability from an open PR or newer source checkout.
MCP cannot read this worktree. Before an MCP review, read [MCP execution](references/mcp-review.md).
Without a tested collector matching the intended scope and exclusions, report the coverage blocker.
An ad hoc `git diff` is not equivalent collection. MCP users skip CLI preflight.
## Execution and recovery policy
These are the canonical gates. References supply command syntax, result dictionaries and platform recipes;
they do not select different authority, compatibility or recovery policy.
- **Trusted runtime:** retain the resolved installed invocation for every call, including `--version`.
Never run repository-local launchers. If neither installed invocation works, stop the CLI path.
Installation requires covering approval and a Qodo/organization-supplied checksum-pinned installer.
Never invent a digest, pipe an installer into a shell, or switch deployments.
- **Compatibility recovery:** old or unparseable versions stop identity, login, reviews and managed tools.
Check only whether `QODO_UPDATE_BASE_URL` is set; never print its value. If set, stop for the user.
Preserve the recorded origin, exact version choices and update holds. Choose one approved route.
Every updater route, including ordinary update, needs a successful check offering a newer compatible 2.x target.
Failure, no update or an incompatible target stops before any runtime change; do not switch routes.
Same-origi
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 11 — file references are metadata, not package contents.
qodo-review-notes30.8 KB
View saved version →
---
name: qodo-review-notes
description: Preserve reasoning for independent review of plans and PRs through Qodo notes tools. Use during substantive planning and development, when decisions, scope or validation change, when resuming or handing off work, and before opening or updating a PR. Tracks hold the evolving plan across issues and repositories; PR notes explain one change. Also use to read or maintain reviewer context. This skill does not review or approve a plan or code, implement it, or open a PR.
owner: Qodo
metadata:
vendor: qodo
version: "1.0.4"
recommended: "true"
package: "qodo"
distribution: "marketplace"
instruction_mode: "embedded"
---
# Development Tracks and PR Review Notes
## Description
A diff shows the change; the author also knows the problem, constraints and reasons behind it.
Preserve that context so an independent reviewer can challenge a plan before implementation and
assess the resulting PR, and another coding session can continue without reconstructing the chat.
Development Track Notes hold the evolving plan across issues, repositories and PRs. PR Review
Notes explain one change and link to a track explicitly. Judge usefulness by the review questions
the notes help answer, rather than their length or number of saves.
## Capture reasoning as work develops
For substantive work with existing notes-maintenance authority, maintain notes as part of the
task without repeated permission questions. A request to read or review alone is not write
authority; preserve a drafts-only instruction and the host's actual write/publication gates.
Read relevant notes at intake or resume. Save meaningful new context when:
- A plan has concrete goals, constraints, proposals or decisions worth reviewing, before coding.
- The chosen approach, scope, assumptions, dependencies or a significant risk changes.
- Verification changes what is known, fails, or leaves an important path untested.
- Work is handed off or paused with new context; a PR is opened or updated with changed work.
Use the track for early plan context; no PR, source commit or implementation is needed to save
a track. A plan-only task stays plan-only. Avoid placeholder records at intake, a track for every
tiny edit, and unchanged saves on every turn. A small independent fix can have PR notes alone.
When nothing relevant changed, reuse the existing revision.
For a reviewable plan, capture the intended outcome, constraints and non-goals; the proposed
approach and its reasons; meaningful alternatives actually considered; assumptions and risks;
dependencies/order; and how the plan will be checked, including unresolved questions for the
reviewer. Scale this to the task instead of filling empty headings. Clearly separate proposals,
user-selected decisions and coding-agent choices, with known rationale. Leave unknown ownership
or rationale explicit. A proposal in notes is neither approval nor authority to implement it.
Keep planned checks separate from completed results; never invent a choice, test or business case.
Keep a concise current summary first. Incorporate new facts into the present account and replace
superseded status text, preserving useful rationale, constraints and other authors' contributions.
Use saved revision history for chronology instead of appending old summaries into the current
body. Resolve conflicts in evidence explicitly; do not silently erase a still-relevant disagreement.
Shared goals and delivery order belong in the track. Each PR note should explain that PR's distinct
behavior, decisions and review risks instead of copying the whole track into every PR.
## Prerequisites
Use an authenticated Qodo connection to the intended deployment and workspace. Notes tools must
be available in the live catalog. For CLI use, require Qodo CLI **2.0.0 or newer** and the
PR commands' `localGitCapture` capability. A trusted MCP connection can supply the same operations.
## Instructions
Discover the tools, select the track explicitl
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 3 — file references are metadata, not package contents.
qodo-review-resolver32.2 KB
View saved version →
---
name: qodo-review-resolver
description: Read or resolve a pull request's Qodo review using Qodo managed tools through MCP or the CLI — fetch structured status, reviewed commit SHA, and findings for ANY PR as JSON, with optional extended details and citation evidence for audits, then optionally resolve open findings and record outcomes, once or until clean. Use this — never `gh`/`curl` scraping of review comments — for "is the review clean on PR #N", "get Qodo's findings for <pr> as JSON", "audit the review evidence", "show finding citations", "what did Qodo flag", "is this review up to date with head", "check before merging", "resolve my PR review", "fix the review findings", or "babysit this PR until it's clean".
triggers:
- "Check the Qodo findings on this pull request"
- "Audit the citation evidence for these Qodo PR findings"
- "Resolve the open Qodo review findings on this PR"
owner: Qodo
when_to_use: When you need to read or act on a pull request's Qodo review — check where it stands, see what it flagged, gate a merge on it being clean at head, or fix the open findings — for any PR, not just your own. It reads the review through qodo's managed tool (structured, git-provider-agnostic), so use it instead of scraping the rendered PR review comments with `gh`/`curl` (lossy, provider-specific, and easy to read stale against the head commit). It resolves findings in local code and then records the outcome on each finding through qodo's own tools (dismiss / mark-implemented, which clear the merge-policy block); it never posts to the git forge itself. Skip it for reviewing code you're writing locally before any PR exists (that's the pre-PR review), and for non-review PR chores (merging, labels, descriptions).
metadata:
vendor: qodo
version: "1.4.10"
recommended: "true"
package: "qodo"
distribution: "marketplace"
instruction_mode: "embedded"
arguments:
- name: autofix
description: Optional shorthand for authorizing supported fixes. An explicit fix request or covering implementation authority also permits those fixes without another prompt.
optional: true
---
# Read & Resolve Findings
## Description
Use Qodo managed tools to read a pull request's **review session** — its status, the commit that
was reviewed, and every finding with its resolution status — for **any** PR (yours or someone
else's). Request extended results when auditing citations or investigating a finding's supporting
evidence, location, dismissal, or review-run history. Reading alone is a valid use: stop after the read to report where a review stands or
what it flagged (e.g. to gate a merge on it being clean at head). To go further, **resolve the
open findings in code**, applying your own judgment (the review is a strong second opinion, not
gospel). Apply supported fixes when the user has authorized them; otherwise present your assessment
for selection. Run once (report + authorized fixes) or as a watch loop (resolve →
let Qodo re-review the new commit → repeat until clean). When separately authorized, **record the outcome** on the findings
you settled — `mark-implemented` for ones you fixed, `dismiss` for ones the user agreed to close
without a code change. That is what clears the merge-policy block those findings hold; skip it and
the review stays red until a human clicks through the PR. You still never post to the forge
yourself: the status tools write Qodo's review DB and Qodo reconciles the PR comments. (Plain
git/forge *metadata* reads — `git rev-parse HEAD`, `gh pr view --json headRefOid` — are fine and in
fact required for the freshness check below; the "don't scrape" rule is about qodo, not your shell.)
## Prerequisites
- A connected QAR managed-tools MCP server or authenticated Qodo CLI exposes review-session tools.
- The exact PR URL and its current head SHA can be resolved without scraping review comments.
- Any finding-status write has explicit user authorization; code-fix authority or `autofix` alone does not coverPreview of the first 4,000 characters. Read full instructions →
Referenced files: 4 — file references are metadata, not package contents.
qodo-setup3.86 KB
View saved version →
---
name: qodo-setup
description: Set up Qodo in a coding agent — install the CLI, sign in, and verify tools. Use after plugin installation, on setup requests, or when a Qodo skill finds a missing CLI or login.
owner: Qodo
metadata:
vendor: qodo
version: "1.0.14"
recommended: "true"
package: "qodo"
distribution: "marketplace"
instruction_mode: "embedded"
---
# Set up Qodo
## Description
Skill installation is not readiness. References are relative to this SKILL.md.
## Prerequisites
Shell or host-connected QAR MCP; never handle credentials.
## Instructions
### Connected MCP
Inspect QAR schemas; call a harmless read and check isError before structuredContent. A catalog proves neither read nor write access; never test-write. Host/QAR own auth. Report missing tools, MT-AUTH-FORBIDDEN or connection errors; never request API keys. For MCP-only setup, hand back. CLI collection uses the same deployment.
### Runtime
PowerShell: resolve the verified native/Node invocation in [runtime.md](references/runtime.md). POSIX: probe:
```sh
qodo --version
```
Then try `"${QODO_HOME:-$HOME/.qodo}/bin/qodo" --version` if missing. Use that verified installer if missing. Setup covers installation subject to host approvals; plugin installation alone does not.
Keep the executable as `<qodo>`. Require Qodo CLI **2.0.0 or newer** before auth; compatible versions skip update preflight.
### Runtime compatibility recovery
For old/unparseable versions, stop authenticated calls and explain. Before update checks/changes, test only whether QODO_UPDATE_BASE_URL is set; never print/change it. If set, stop for user resolution. All routes preserve origin, exact versions and update holds; never replace an exact version with a channel.
For parsed1.x, normal `qodo update` reaches approved stable2.x only if that origin enables migration. Require a newer compatible same-origin2.x target from the selected route's supported check. If legacy aliases serve1.x, check latest-2 before proposing `qodo update --channel latest-2`. Missing/failed checks stop; never assume activation or unrelated future-major authority.
For unparseable version/no supported updater, use the checksum-pinned installer reference. Preserve supported customer selectors/settings; normal verified installation selects the approved version. Explain the route; reuse covering runtime/installation authority or ask once before changing it. Make one approved attempt, reprobe unadorned version, and stop on denial/failure/incompatibility without another route, skill edits or an auth diagnosis.
### Connect and verify
Run:
```sh
<qodo> read whoami --json --skill qodo-setup --skill-version 1.0.14 --distribution marketplace --host codex
```
Reuse success. Read [authentication.md](references/authentication.md) before login on failure; preserve deployment, never fall back to Cloud. Wait/recheck identity; stop on denial/cancellation. Diagnostic approval is not blanket authority.
Only after identity succeeds run:
```sh
<qodo> tools --refresh --json --skill qodo-setup --skill-version 1.0.14 --distribution marketplace --host codex
```
Require task capability. On failure report signed in but tools unavailable, exact error and that retry; do not log in again. Reuse verified context with host approvals.
## Configuration
Setup does not authorize enterprise installation/maintenance. Disclose packages/maintenance; preserve opt-outs, edits, owners and choices. Never install optional Standards. For QODO_NOTICE/repeated Kiro read approvals read [host-recovery.md](references/host-recovery.md). CLI owns credentials/transport/updates; lifecycle owners update skills.
## Error Handling
Report the error and one next action. Never claim readiness after failure, disable Keychain, copy credentials, change permissions or offer unrestricted approvals.
## 4. Hand off
Confirm Qodo connection/tools and return to the task. Readiness does not guarantee later access.
Referenced files: 5 — file references are metadata, not package contents.