Launch · VS Code extension · v0.6.6

ADO Code

Your Azure DevOps backlog, shipped by AI — inside the editor.

Fetch work items as a real hierarchy, chat with any LLM, and delegate tasks to coding agents — each in its own isolated git worktree.

VS Code 1.85+
OpenAI-compatible & Anthropic
Open source
No telemetry

Launch framing: one sentence pitch. ADO Code is the bridge between the Azure DevOps board and the code — an AI assistant that turns work items into merged pull requests.

The problem

The board and the code never talk.

01

Work lives in two places

Your work items live in Azure DevOps — the code lives in the editor. The thread between them is manual.

02

Copy-paste plumbing

Branch names, work-item IDs, PR links — hand-built every time. Slow, and easy to get wrong.

03

Agents are blind to the backlog

Claude Code, Codex and the rest are powerful — but they don't know your items, your state, or your context.

04

Every switch drops the thread

Board → editor → agent → PR. Each hop loses the context the last one had.

Set up the pain before the pitch: fragmented workflow between ADO and the editor, and agents that don't understand the backlog.

The idea

One loop, from backlog to merged PR.

ADO Code turns a work item into a branch, hands it to an agent, and closes the loop with a pull request.

After merge, Clean Up After Merge removes the worktree and branch — only once the PR is actually merged.

The core narrative: one loop. Emphasise the final step is automated — commit → push → PR → merge → cleanup — so an item is fully closed out, not just "worked on".

The product

An AI coding assistant built for Azure DevOps.

Work-item tree

Your backlog as a real Epic → Feature → Story → Task hierarchy.

Any LLM

OpenAI-compatible (OpenRouter, Ollama, LM Studio…) and Anthropic.

Four modes

Chat, Plan, Act and YOLO — one toggle from ask to autonomy.

External agents

Delegate to Claude Code, Codex, OpenCode, Hermes, Pi, dsh.

Isolated worktrees

Every run gets its own git worktree — agents never collide.

MCP + skills

Plug in tool servers or load from a built-in skill catalog.

High-level capability map. Keep it to six: tree, model, modes, agents, worktrees, MCP/skills. Memory gets its own slide later.

Work items

Your backlog, as a real tree.

True parent-chain nesting — even when parents belong to someone else
My / All / Unassigned views in one visible toggle
Filter by state, type or text — collapsed parents stay visible
Assignment cues: blue = you, orange = them, grey = unassigned
Take ownership or reassign right from the tree
Opening an item auto-creates a feature/ADO-<id>-<slug> branch

Detail the work-item tree. Highlight the branch-on-pickup behaviour — it feeds directly into the delegation loop.

AI chat

Any model. Four modes.

default

Chat

Ask, then approve — every action as a consent card.

read-only

Plan

Inspect the repo and propose — nothing edits, nothing runs.

allowlist

Act

Edits applied, commands run against a wildcard allowlist.

autonomy

YOLO

Full autonomy — push still asks, even here.

Every mode shares the same chat, memory and work-item context. Consent cards carry a live countdown that pauses while you're away.

Walk the four modes left-to-right as an escalation of trust. Note YOLO still gates push by default — that's the guardrail that makes autonomy safe.

Agents & worktrees

Your backlog, delegated.

⌘Claude Code

⌬Codex

❯OpenCode

✧Hermes

πPi

≫DeepSeek Harness

Each run gets its own isolated git worktree under .ado-code/worktrees/ — parallel agents can never collide on a branch.

Position ADO Code as an orchestrator, not a competitor: it delegates to the agent you already trust, each sandboxed in its own worktree.

Finish the job

From commit to merged PR, automatically.

1commit_worktreeCommit the agent's changes

2push_worktreePush to the remote

3create_pull_requestOpen the ADO pull request

4auto-reviewLLM reviews the diff, recommends merge

5resolve_pr_conflictsAI fixes conflicts, re-pushes

6clean upRemove worktree + branch after merge

Guardrails

Never force-pushes
Refuses protected branches (main / master)
Refuses failed runs
Blocks concurrent runs on the same item
Warns on stale branches

The "finish the job" story: the assistant doesn't stop at code — it pushes, opens the PR, reviews, resolves conflicts and cleans up. Guardrails keep it honest.

Context

Context that persists.

Memory

User memory across sessions
Workspace conventions in .ado-code/memory/
agent.before / agent.after hooks
Fuzzy search, import & export

MCP servers

External tool servers, configured in the UI
Connect, disconnect & inspect per server
AI discovers tools mid-conversation

Skills

10+ built-in (Code Review, Testing, Refactoring…)
Import from JSON, SKILL.md or archives
Community registries via TSV

Memory is injected into every chat and every agent handoff — and auto-ignored by git & Docker.

Context is the moat: the assistant remembers the user and the project, and it can extend itself with MCP servers and skills.

Guardrails

Autonomy, with guardrails.

Consent cards with live countdowns — pause while you're away
File checkpoints before every AI edit
Protected branches refused, force-push never allowed
Push approval stays on even in YOLO mode

Read-only commands run instantly; risky ones ask
Batch edits verified and applied in order
Truncated-response guard — no half-executed tools
No telemetry · no account · open source

Trust story: autonomy is the feature, guardrails are the contract. No telemetry and open source close the loop for enterprises.

Visual Studio Code — ado-demo (Workspace)

You

Pick up ADO-123 and implement the Stripe integration.

ADO Code

On it — I'll work through ADO-123, then hand the branch back for review.

✎ edit_file completed

src/payments/stripe.ts · 2 edits applied

/Ask ADO Code to work your items…

☰ ADO Code working…feature/ADO-123-stripe-integration

Demo

Inside VS Code.

The work-item tree on the left — live ADO hierarchy
The chat on the right, with thinking and tool cards inline
Status bar shows the active item, mode and branch
One session, one item — the whole loop in one place

Walk the mockup: left is the backlog, right is the agent chat, bottom is the branch and status. This is the entire product surface in one screen.

Release · v0.6.6

What's new in 0.6.6.

Tool hardening

Workspace delete_file tool
Batch read_file + read cache
Degenerate-loop circuit breaker
Quote-aware shell safety + Windows builtins

Context & workflow

Overhead-aware context truncation
CJK & dense-code token weighting
Per-organization PATs
Unattached / standalone mode

UI surface & branding

Interactive Mermaid + SVG export
Chat in the editor area
Header quick actions
Custom icons + secondary sidebar

Presenting right after the 0.6.6 release? Land the delta: tool-system hardening (delete_file, batch reads, loop breaker, shell safety), token-accounting correctness, per-org PATs and standalone mode, plus the UI surface refresh (Mermaid, chat in the editor, header actions, secondary sidebar).

Install

Up and running in a minute.

1Install

From the Marketplace, or right from the terminal.

code --install-extension steelburn.ado-code

2Connect ADO

Organization, project, and a PAT with vso.work_write scope.

3Add a model

Bring your own key — any OpenAI-compatible API or Anthropic.

Requirements: VS Code 1.85+ · Node.js 18+ · a git-enabled workspace. No telemetry, no account beyond your own providers.

Three-step onboarding. Mention the Marketplace and the terminal install command. Requirements are minimal — that's part of the pitch.

Launch film

See it in motion.

93 seconds · narrated · 1080p

Play the narrated launch film (93s). It follows the same arc as this deck: the problem, the loop, the modes, delegation, what's new in 0.6.6, and the call to action.

ADO Code · v0.6.6

Ship your backlog.

Free, open source, no telemetry. Connect ADO, bring a model, delegate the rest.

Install from Marketplace GitHub

steelburn · Khairulnizam Hasan · made for VS Code & Azure DevOps

Close with the call to action and the open-source, no-telemetry reassurance. Point to Marketplace and GitHub.