November 16, 2026

Powering Agile Teams with Claude and Azure DevOps

With one plugin, we standardized the creation of work outputs in Azure DevOps while preserving human control.

Author: Sean James

In just five months, 386 work items were created in Azure DevOps (ADO) through Claude, and a human approved each and every one. Getting AI tools into a delivery team’s hands is the easy part. The hard part is making sure everyone’s output looks the same, follows the same rules, and lands where the team works, not in a chat window waiting to be copied and pasted. Here’s how we solved that with Claude and Microsoft’s open-source Azure DevOps MCP server: the setup, the guardrails, how we organized it, and how we rolled it out. 

Setup

The first piece of the puzzle was to add the ability to connect the Azure DevOps project directly to our Claude workspace. This removes the need to create tickets by hand in ADO and fill them out from scratch.  The open source MCP for Azure DevOps was the right fit. This MCP is a connector that we can add to our Claude Desktop that would run and give the user access to the full Azure DevOps context directly in their chat with Claude by exposing these tools: 

  • Work items: create and update stories, bugs, and tasks
  • Repos: pull requests, branches, and code search
  • Pipelines: builds, runs, and artifacts
  • Test plans: test cases and results
  • Wiki: read and publish pages
  • Boards: iterations and teams 

One major hurdle was that Claude Desktop can’t sign in to Microsoft’s remote-hosted MCP server with Microsoft Entra ID. The fix was running the server locally. Each user installs Node.js 20+ and adds one entry to Claude’s MCP config, and Claude starts the server when the app opens. The first tool call opens a standard Microsoft sign-in, so every action still runs under the user’s own ADO permissions.

Once the MCP was running users could prompt Claude with questions or tasks like “List work items in current iteration for RevGen project”, “Create a bug named “Submit Button Broken” and assign it to Sean James”, or “Tell me in the UI how I can get to the Submit Feedback textbox”. 

Guardrails

Raw access isn’t enough. Without standards, ten people produce ten ticket formats, and an AI that can write to your backlog needs limits. We applied least privilege at three levels:

  • Scope the server: Load only the tool areas a workflow needs.
  • Scope the account: Permissions come from the signed-in user’s ADO role.
  • Scope the client: In Claude Desktop, enable only the MCP tools a workstream uses.

Most importantly, Claude never writes to ADO without explicit approval. Every item is shown as a full draft first. Every approved item is also tagged “ADO MCP Created,” which gives us an audit trail and the adoption numbers below. Because ticket text and comments are content Claude reads, we treat them as untrusted input, and the approval step is what keeps a stray instruction in a work item from turning into a write.

The same four steps run every time: 

  1. Fetch live context from ADO
  2. Draft the item
  3. Confirm with the user
  4. Act in ADO

Organization

With the MCP running, the harder work began: organizing the standards and making skills work together. To do this we created a Claude plugin, a single “folder” of skills and instructions that can be used and shared across the team. The first skill governs interaction with the MCP itself: project rules, access limits, language and formatting, and general best practices for working with ADO. Skills are where “what good looks like” gets written down. For example, the ticket skill requires every story to carry acceptance criteria in the team’s format, a story point estimate on a fixed scale (1, 2, 3, 5) with a check on whether the story should be split, and proof of technical context inclusion. Because they live in one plugin, each skill knows about the others . and works with the general ADO rules skill, so everything is covered and lands in ADO in a standard way, and the whole set can be shared with coworkers without anything missing.

In Practice

A Teams thread confirmed that a piece of work was moving to the backlog. Our product owner gave Claude a one-line request, with no ADO fields spelled out. Claude returned a structured story with title, sprint, tags, and description. Our product owner then confirmed it and, in the same reply, asked Claude to assign it to a developer and leave a comment for the original requester. One exchange, done.

Test cases work the same way. After the last story in a batch was created, Claude drafted a 12-step test case. On approval, it linked the test case to the story and added it to the correct test suite. The parent feature ended up fully traceable, with 14 stories and 15 test cases linked end to end.

Because the server can also search the codebase, non-technical team members can ask how something works while writing a story. Their answers come from the actual code, not assumptions or stale documentation.

Deployment and Impact

Putting the skills and MCP configuration in one central plugin lets us share it across the company, with each person getting the tools and skills in one folder. When we push updates to the plugin, users who installed it pick them up automatically, so no one is required to download and replace old files.  The distributor only needs share a link and grant access. Someone owns the plugin: skill changes are reviewed before they’re published, so a change to “what good looks like” is deliberate rather than accidental. 

Since the first item on June 10, 2026, the RevGen ADO Project has had 386 work items through the MCP and tagged “ADO MCP Created”: 235 user stories, 94 bugs, 51 test cases and 6 tasks. Adoption grew every month, from 1 item in June to 43 in July, 104 in August, 111 in September and 127 in October (through the 27th). Weekly volume peaked at 55 items the week of October 19th.

The Takeaway

The biggest lesson wasn’t technical. Connecting Claude to Azure DevOps was a one-time effort; deciding what “good” looks like and writing it down as shared skills is what made AI usable for the whole team. When standards live in one governed plugin instead of in individual prompts, every story, test case, and release note looks the same no matter who requests it. Requiring human approval for every write keeps the team’s trust in what lands in the backlog. The pattern works for any team: connect AI to where the work lives, set standards once, and keep a human in the loop.

Sean James is a Senior Technical Consultant at RevGen with a focus in AI engineering and development. His background as a full stack software engineer has led him to build AI gateway solutions and AI tools that save teams time, money, and overhead.

 

Subscribe to our Newsletter

Get the latest updates and Insights from RevGen delivered straight to your inbox.

RevGen
Privacy Overview

This website uses cookies so that we can provide you with the best user experience possible. Cookie information is stored in your browser and performs functions such as recognising you when you return to our website and helping our team to understand which sections of the website you find most interesting and useful.