ADO Code — AI coding assistant with Azure DevOps integration for VS Code

VS Code extension · steelburn.ado-code · v0.6.3

Turn Azure DevOps work items into shipped code.

ADO Code brings your backlog into the editor. Fetch work items as a real Epic → Feature → User Story → Task hierarchy, chat with any OpenAI-compatible or Anthropic LLM, and delegate tasks to coding agents — Claude Code, Codex, OpenCode, Hermes, DeepSeek Harness — each in its own isolated git worktree.

Install from Marketplace
  • VS Code 1.85+
  • OpenAI-compatible & Anthropic
  • Git worktrees
  • MCP support
  • Open source
Visual Studio Code — ado-demo (Workspace)
You
Pick up ADO-123 and implement the Stripe integration.
ADO Code
Planning: read the checkout module, find the payment stub, wire the Stripe API…
On it. I'll work through ADO-123, then hand the branch back for review.
read_file completed
src/payments/checkout.ts · 214 lines
edit_file completed
src/payments/stripe.ts · 2 edits applied
/ Ask ADO Code to work your items… (try /pick, /delegate, /generate-tasks)
☰ ADO Code working… Chat · tokens 2,431 · feature/ADO-123-stripe-integration

Features

Your backlog, in your editor.

Every feature is built around one loop: pick an item, let AI work it, review the branch, merge the PR.

One tree view for the whole backlog

Work items render as the real ADO hierarchy — Epic → Feature → User Story → Task — with a visible header toggle between My Work Items, All Work Items and Unassigned. Hierarchy-context rows are tagged, state/type/text filtering is built in, and a green badge marks the item you're working.

  • Parent-chain walk for true nesting, even when parents belong to someone else
  • Assignment cues — blue = you, orange = someone else, grey = unassigned
  • Take Ownership / Reassign right from the tree
  • Open items spawn feature/ADO-<id>-<slug> branches automatically

Agent worktrees

Every delegated run gets its own git worktree under .ado-code/worktrees/ — parallel agents can never collide.

  • Run status, dirty files, ahead/behind at a glance
  • Open in Terminal / Explorer, diff, remove
  • Concurrency guard: no overlapping runs on the same item

Memory that persists

User memory remembers you across sessions; workspace memory keeps project conventions in .ado-code/memory/ — auto-ignored by git & Docker.

  • agent.before / agent.after shell hooks
  • Fuzzy search, import/export

MCP & skills

Plug in external MCP tool servers, or load from a built-in catalog of 10+ skills — Code Review, Security Audit, Testing, Refactoring and more.

  • Skill import from JSON, SKILL.md or archives
  • Community skill registries via TSV

Model-aware by design

Capabilities are detected per model — vision, tool calling, context window — so the UI never offers what your model can't do.

  • Live /models data from OpenRouter or Ollama
  • Per-model overrides when auto-detection is wrong
  • Real token counting in the status bar

An AI that finishes the job

For delegated runs, ADO Code closes the loop itself: commit → push → open the pull request — never force-pushing, never touching protected branches. Finished runs get an LLM auto-review with a merge recommendation, and after the PR merges, Clean Up After Merge removes the worktree and the branch.

  • commit_worktreepush_worktreecreate_pull_request
  • resolve_pr_conflicts lets the AI fix merge conflicts, then re-push
  • Parent delegation covers the whole subtree with a numbered delivery checklist

Feature reference

Everything ADO Code does.

The complete feature set of v0.6.3, straight from the release notes — grouped by area. Rows marked new · 0.6.1 / new · 0.6.2 / new · 0.6.3 landed in the latest releases.

Work Items11
Hierarchical treeWork items render as the real ADO hierarchy — Epic → Feature → User Story → Task — with a parent-chain walk, so nesting survives even when parents belong to someone else (hierarchy-context rows tagged “· context”).
View mode toggleOne tree with a visible header: My Work Items / All Work Items / Unassigned — click to switch, remembered per workspace.
Filtering & searchFilter the tree by state, type, or text search with smart parent visibility — collapsed parents stay visible when a child matches.
Take Ownership / ReassignContext-menu actions gated per item, available in every view mode; selected items show a green badge and can be deselected.
Full detail viewRight-click → Show Full Details opens a formatted panel in the editor with the item's full content.
Task draft editorWhen the AI calls create_work_item, an editable markdown tab opens for review before anything is created — markdown is converted to HTML for proper ADO rendering.
Generate tasks from stories/generate-tasks has the AI analyze a user story and draft child tasks — with duplicate prevention against existing children.
Project binding & stateWorkspace-to-ADO project binding prevents working items from the wrong project; /status, /comment, /assign and /undo drive the active item.
Rich-text imagesScreenshots inside Description, Acceptance Criteria, Repro Steps and comments are fetched with your PAT and inlined as data: URLs — no more broken images in the detail panel (capped at 10 images / 2 MB each / 8 MB total per field).
Assignment cuesEvery item shows who owns it — blue person = assigned to you, orange = someone else, grey = unassigned — with the type in the row description and the assignee on hover.
Batch work-item readsget_work_item accepts an ids array — fetch up to 20 work items in ONE call (details batch-fetched, discussion threads loaded in parallel) instead of N round-trips.
💬AI Chat & Modes17
Any LLM, one chatOpenAI-compatible APIs (OpenRouter, Ollama, LM Studio…) and Anthropic — bring your own key and model.
Chat / Plan / Act / YOLOClick-to-switch tool modes: Chat (ask + approve), Plan (read-only), Act (auto-approve with allowlist), YOLO (full autonomy) — also cycled from the Status Panel.
Agentic tool loopTool calling with an agentic loop, mode-aware system prompts (role, tools, guidelines, environment) and a configurable tool budget per turn.
Parallel tool callsIndependent tool calls run concurrently and re-order back to call order; same-file edits serialize through a per-file mutation queue. Mixed batches stay fast too — consent-free calls execute in parallel while approval-gated ones run sequentially, so read-only work never waits on your click.
Batched editsedit_file accepts an edits[] array — several disjoint changes in one call, each verified and applied in order.
Batched terminal commandsrun_terminal_command accepts a commands array — several commands in ONE call, each still checked for shell operators and the Act-mode allowlist, outputs concatenated under $ command headers with a single consent card.
search_files grep toolRegex search across the workspace with path:line hits, per-line truncation, workspace confinement and result caps.
Live thinking & tool cardsThe AI's reasoning streams into a 💭 block; each tool call appears as a live card — running… → completed/error — and persists as a collapsible record in the final message.
Privacy togglesHide tool calls entirely (subtle “…” only) and toggle AI thinking on/off — enforced across every streaming path.
AI choice detectionWhen the AI offers options they render as clickable buttons; a fenced ```choice block is the primary path, with regex and an optional cheap-model fallback.
In-chat confirmation cardsTask start, mode switch and every consent prompt render as styled cards inside the chat — destructive operations use danger styling.
Send Selection / File to ChatRight-click editor selection or an Explorer file to insert it into the chat — selections as fenced code, files as attachment chips.
Slash commands/pick, /delegate, /generate-tasks, /new-project, /skills, /remember, /clear-sessions… with autocomplete and categorized /help.
Working indicatorStatus-bar spinner with live detail (“thinking…”, “tool: edit_file”) — visible even when the chat view is hidden.
Truncated-response guardIf a reply hits the output token limit, tool calls fail with “re-issue” instead of executing possibly-truncated arguments.
Active editor contextThe file you're editing is auto-injected into every chat turn — deduplicated by file/version, oversized selections capped, no copy-paste required.
AGENTS.md in chatThe chat model reads and honors an AGENTS.md at the workspace root on demand — parity with agent handoffs, zero cost when absent.
🤖Agents & Worktrees13
External agent orchestrationDelegate to Claude Code, Codex, OpenCode, Hermes, Pi, DeepSeek Harness (dsh) and more — each declared by binary, supported modes and CLI arguments, with a details panel.
DeepSeek Harness (dsh)First-class agent support — auto-detected via dsh --version and delegated through the headless profile (prints the final answer, exits 0 on success). Available from chat, /delegate, the work-item context menu and the delegate_to_agent tool.
Worktree isolationEvery delegated run gets its own git worktree under .ado-code/worktrees/ — concurrent agents can never collide on branches.
Worktrees viewDedicated sidebar tree with per-worktree details: run status, agent, dirty/clean files, last commit, ahead/behind — plus Open in Terminal/Explorer, Remove, Show Changes and Show Agent Output.
Reopen agent outputFinished runs keep a ↗ Reopen button and right-click → Show Agent Output — the summary panel is never permanently lost.
Run history & progressRecent Runs (last 10) in the Status Panel with status icons and timestamps; agent progress streams in the chat thread with a live elapsed clock, or into the editor area as a full panel.
Parent delegationDelegating a parent item runs its whole subtree in ONE worktree — the agent gets a numbered delivery checklist and must sign off with a ## Delivery Report (DONE / BLOCKED / INCOMPLETE).
Auto-complete childrenWith adoCode.agents.autoCompleteChildren, done children transition to their terminal state and the parent closes when all are done — partial success leaves it open with a comment.
AI merge flowThe assistant commits, pushes and opens the ADO PR itself (commit_worktreepush_worktreecreate_pull_request), and can resolve merge conflicts (resolve_pr_conflicts) then re-push until the PR is clean.
GuardrailsNever force-pushes, refuses protected branches (main/master), refuses failed runs, blocks concurrent runs on the same item (parent/child included), and warns on stale branches.
Auto-reviewGit diffs are reviewed by the LLM on completion with a merge recommendation; AGENTS.md context is injected into every agent handoff.
Clean Up After MergeRemoves a merged run's worktree and deletes its branch — only when the PR is actually merged — from the view or as an auto-offer.
Summary panelCompletion summaries open in a styled HTML panel with metadata and duration; batch cleanup removes all completed worktrees at once.
Git Workflow5
Branch on pickupAuto-creates feature/ADO-<id>-<slug> branches when a task starts (slugged from the work item title).
Changelog on completionUpdates CHANGELOG.md when a task finishes, with optional auto-commit and posting the entry back to ADO as a comment.
PR on doneOffers to push and open a PR via gh when a task completes; protected-branch checks keep the AI honest.
Worktree diff viewerShow Changes opens the VS Code diff editor for worktree files before you commit.
Safety checksWarns on branch switches with uncommitted changes; refuses to silently discard dirty worktree state (offers Commit & Push, then Remove).
🧠Memory6
User memoryAI remembers your preferences across all sessions via /remember and /forget.
Workspace memoryProject conventions in .ado-code/memory/ — conventions, architecture, gotchas, custom — kept out of git/Docker via auto-ignore.
Agent hooksagent.before / agent.after keys run shell commands around every agent invocation (e.g. lint before, tests after), streaming output to the run panel.
Memory injectionUser + workspace memory is injected into the chat system prompt and into every external-agent handoff (“ADO Code Memory — instructions you MUST honor”).
Search & transferFuzzy QuickPick search across all memory entries; move entries between user and workspace scope.
Import / exportExport memories to JSON; import with merge or replace — memory survives reinstallations.
🧩MCP & Skills7
MCP serversModel Context Protocol support for external tool servers — configure in the UI, right-click to disconnect/reconnect/view details.
Skill catalogBrowse, install and manage reusable AI skills — 10+ built-in (Code Review, Documentation, Testing, Refactoring, Security Audit, Performance Profiler, Deployment Checklist, Database Schema Review, Accessibility Audit) with search and enable/disable.
AI skill executionThe AI can discover and run enabled skills mid-conversation via execute_skill; “Execute in Chat” injects the skill prompt and triggers the LLM.
Skill importBring your own skills from JSON, SKILL.md (YAML frontmatter + markdown) or .tar.gz/.zip archives — they persist across restarts.
Skill registriesBrowse community skills from remote TSV registries (slug<TAB>url<TAB>description) — registry skills are badge-marked and imported on install.
Project creation wizardMulti-step wizard for 9 templates — Node.js (TS/JS), Python, React, Next.js, Laravel, .NET Web API/Console, Empty. Creates projects anywhere: the open workspace folder (blank directories included) is used automatically or you pick one; ADO integration creates the work item in your active project, template option defaults pre-fill, the chosen initial branch is honored and invalid project names are rejected up front (/new-project).
File checkpointsAuto-save before AI edits, restore on demand — a safety net for autonomous runs.
Model Intelligence & Context8
Capability detectionVision and tool-calling support inferred per model — image attach is disabled for non-vision models, and models without tools get a persistent warning. Three layers: per-model overrides > live gateway data > name heuristic.
Capability overridesadoCode.llm.capabilityOverrides declares vision/tool support per model id when auto-detection is wrong — edited as structured rows in the Configuration page.
Dynamic context windowContext size auto-detected from /models (Ollama n_ctx, OpenRouter context_length…) — live data overrides the built-in table (27 models, 128k default).
Context managementPriority-based truncation replaces a naive turn cutoff; content-aware token counting (code ~3.5, prose ~4.5 chars/token); conversation auto-condenses at 75% via LLM summarization.
Native token countingStatus bar uses the provider's own tokenizer (Anthropic count_tokens; OpenAI-compatible usage.prompt_tokens) with local estimates as fallback — forced on for Anthropic, and the count includes the current system prompt.
Per-mode modelsAdvanced mode assigns different models and reasoning effort (low/medium/high) per mode — { "inline": "gpt-4o", "act": "o3" }.
Token optimizationTool results are capped to a token budget and compacted after the model has seen them; plan mode sends only read-only tool schemas.
Understanding cacheA durable, fingerprinted cache in .ado-code/understanding/ holds repo facts, the selected work item and prior-session knowledge — injected into every chat session and every delegated-agent prompt. Invalidates on git HEAD/branch or config change; the LLM repo summary regenerates async (adoCode.understanding.autoSummarize).
Configuration & UX8
Configuration pageSettings grouped into sidebar categories — Connection, AI & Modes, Permissions, Workflow, Integrations — each with a setting-count badge; Advanced toggle gates per-mode models, capability overrides, choice detection and native token counting.
Focused wizard viewsOpening the Configuration page, the project wizard or first-run setup collapses the sibling sidebar views so the wizard gets the full view container — they are restored when it closes, and views you had hidden yourself stay hidden. The chat kebab’s “Configuration…” now opens the in-app Configuration page instead of VS Code’s native settings.
Consent systemRead-only commands can auto-approve after a configurable timer (default 20s); tool auto-approve accepts wildcard patterns (read_*, get_*, edit_file); Act-mode terminal allowlist supports git *, npm run *.
SessionsAuto-create on first message, /resume to continue, per-project retention caps, and /clear-sessions / “Delete All Sessions” to start completely fresh — persistence keeps only the last 25 message pairs so restores stay slim.
Keyboard shortcutsCtrl+Shift+M (cycle mode), Ctrl+Shift+/ (search memories), Ctrl+Alt+R (refresh status).
Update changelogAfter a version change, a one-time notification offers the new version's changelog in a styled webview panel.
Workspace scaffoldingNew-project wizard generates code, AGENTS.md and git init prompts; workspace-to-ADO binding keeps you in the right project.
DiagnosticsTree expansion counts, raw System.Parent samples and per-refresh tree shapes are logged to Output → ADO Code — a flat tree is instantly diagnosable.

Modes

One toggle from ask to autonomy.

Click a mode to see what it allows. Every mode shares the same chat, memory and work-item context.

Chat — ask, then approve

The safe default. The assistant can use tools, but every action is presented as an in-chat consent card before it runs. Read-only commands can auto-approve after a configurable timer.

consent cardsharmless-command timertool auto-approve patterns

Plan — look before you leap

Read-only mode. The model inspects the repo, the work item and its acceptance criteria, then proposes a plan. Nothing is edited, no commands run — the plan comes back as a summary you can approve or refine.

read-only schemasrepo inspectionproposal output

Act — the agentic workhorse

Edits are applied directly, terminal commands run against a wildcard allowlist (git *, npm run *…). Independent tool calls execute in parallel, and batched edit_file edits are serialized per file.

terminal allowlistparallel tool callsbatched edits

YOLO — full autonomy

Every tool, every command, no prompts. Intended for trusted tasks on isolated worktrees where a mistake costs a reset, not a production incident. Checkpoints keep restores one click away.

no consent promptsfull tool accesscheckpoints on

External agents

Delegate to the agent you trust.

ADO Code orchestrates external coding agents instead of competing with them — pick the right tool for the task, straight from the chat.

Claude Code

Full agentic coding with Anthropic models, driven by natural-language prompts.

Codex

OpenAI's CLI agent for focused, file-level implementation work.

OpenCode

Open-source terminal agent — bring your own model and workflow.

Hermes

Nous Research's agent platform, orchestrated right from the chat.

Claude Code, Codex, OpenCode, Hermes, Pi and DeepSeek Harness (dsh) are detected out of the box — add your own via adoCode.agents.enabled, each declared by binary, supported modes and CLI arguments, with a details panel. Delegating a parent item runs its whole subtree in one worktree, with a numbered delivery checklist the agent must sign off in a ## Delivery Report — and with adoCode.agents.autoCompleteChildren on, done children transition to their terminal state automatically.

Slash commands

The backlog, by keyboard.

Type / in the chat input — autocomplete included.

CommandWhat it does
/pickBrowse the work-item tree and set your active context
/status <state>Move the active item — Active, Done, Closed, Removed…
/comment <text>Post to the item's discussion thread
/assign <who>Reassign the active item to a teammate
/delegate [agent] <prompt>Hand the task to claude, codex, opencode, hermes, pi, dsh…
/generate-tasksAI analyzes a user story and drafts child tasks (dedup-aware)
/new-projectScaffold a project — Node, Python, React, Next.js, Laravel, .NET
/skillsBrowse, install and manage reusable AI skills
/remember · /forgetStore or wipe AI memory
/mode [mode]Switch Chat / Plan / Act / YOLO on the fly
/undo · /clear · /resume · /helpRevert, reset, continue a session, or get categorized help

Install

Up and running in a minute.

1 · Install the extension

From the Marketplace, or right from the terminal:

code --install-extension steelburn.ado-code
Open in Marketplace →

2 · Connect Azure DevOps

The extension walks you through it — you'll need:

  • An ADO organization, project, and a PAT with vso.work_write scope
  • Optional: on-prem ADO Server (TFS) base URL

3 · Add an LLM

Bring your own key — any provider speaking the protocols:

  • OpenAI-compatible APIs — including OpenRouter, Ollama, LM Studio
  • Anthropic API
  • Per-mode models and reasoning effort in Advanced mode

Requirements

  • VS Code 1.85.0+
  • Node.js 18+
  • A git-enabled workspace folder

No telemetry. No account required beyond your own ADO + LLM providers. Open source on GitHub.