Sprint Planning Agent

Engineering teams lose 2–4 hours every sprint to manual planning. The Sprint Planning Agent gives that time back — guided, AI-powered, and built around team decisions.

Overview

A full-stack web application that guides engineering teams through sprint planning using a structured, AI-assisted workflow. The core insight: AI recommendations are most useful when they’re grounded in the team’s own retrospective findings and known technical debt — so both feed directly into the sprint planning decision.

The application has two parts:

Sprint Planning Wizard — a 4-step guided flow: analyse the retrospective, prioritise tech debt, plan the sprint, then review the summary. The AI is explicitly told about selected action items and debt before choosing backlog items.
Agile Analyser — standalone analysis tools for retrospectives, tech debt, and code review.

“The AI does the analytical heavy lifting. The team makes the decisions.”

The Challenge

Engineering teams spend 2–4 hours in sprint planning sessions manually reviewing backlogs, calculating capacity, and balancing work across team members. The process is repetitive, the decisions are often inconsistent, and the entire team is pulled away from development work to do it.

Multiply that across 26 sprints a year and you’re looking at 50–100 hours of engineering time spent on planning mechanics — before a single line of code is written.

The Solution

The Sprint Planning Wizard enforces a deliberate order: understand what went wrong last sprint before deciding what to build next.

Sprint planning sessions reduced from 2–4 hours to under 30 minutes.

Step 1 — Retrospective Analysis Paste the team’s retrospective notes. The AI returns overall sentiment, key themes, wins, concerns, and action items paired with experiments (hypothesis → action → success metric). Select the items to carry forward. Use the + button on any item to convert it into an Azure DevOps work item — it appears at the top of the backlog in the next step, ready to be selected.

Step 2 — Tech Debt Review Paste a list of tech debt items. The AI returns prioritised items scored by business impact, risk, effort, and ROI. Critical items are visually highlighted. Select what to address this sprint and optionally convert them to ADO work items.

Step 3 — Plan Sprint Shows the ADO backlog alongside items pinned from steps 1 and 2. Click Plan Sprint to send everything to the AI — selected retro action items and tech debt items are injected into the planning prompt as explicit priorities. The AI produces a recommendation with transparent reasoning for every decision. Review and adjust the selection before committing. The selected points tally is colour-coded against team velocity.

Step 4 — Summary Confirms the sprint was created and displays a structured summary: capacity, retrospective items addressed, tech debt items addressed, and all backlog items selected.

The AI handles the analysis. The team owns the plan. Nothing is written to Azure DevOps until the team confirms.

Full Lifecycle Coverage

Sprint planning is just the beginning. The Agile Analyser brings AI augmentation to every stage of the development lifecycle:

Retrospective Analysis — extracts themes, sentiment, and actionable items from retro data
Technical Debt Prioritization — ranks debt items by ROI and business impact
Code Review — flags issues, security concerns, and best practices before they reach production

One platform. The full development lifecycle covered.

How It Works — The ReAct Pattern

The SprintPlanningOrchestrator implements a ReAct (Reasoning + Acting) loop capped at 10 iterations:

Reason — analyzes the current state and decides what information it needs
Act — calls the appropriate tool based on context, not a hardcoded workflow
Observe — reviews the result and determines the next step

Three autonomous tools drive the planning process:

get_backlog_items — retrieves work items from Azure DevOps
get_team_velocity — calculates sprint velocity from historical data
create_sprint — records the AI’s recommendation for team review; no ADO write until confirmed

Tool execution errors are returned as strings to Claude so it can recover gracefully — the loop never crashes the request. The iteration cap limits the blast radius of any runaway loop.

Architecture

Two independent ASP.NET Core APIs share a common class library:

Sprint Planning API — orchestrates the AI agent, manages ADO integration, exposes the wizard endpoints
Agile Analyser API — delivers structured AI analysis for retrospectives, tech debt, and code review
Shared library — API key middleware used by both services

The frontend is a React 19 + TypeScript SPA communicating with both APIs in real time.

Mock mode is built in — set UseMock: true to run the full wizard against a stub service with no Azure DevOps credentials required.

Security

API key authentication — requests without a matching X-Api-Key header are rejected with 401. Skipped entirely in local development.

Tiered rate limiting — fixed-window per IP address:

3 req/min for the AI planning endpoint
5 req/min for sprint creation
10 req/min for all analyser endpoints
30 req/min for general backlog and velocity endpoints

Prompt injection defence — the application processes untrusted external data (backlog titles, retro notes) that flows into Claude’s context. Mitigations include system prompt anchoring, input sanitisation that strips control characters and flags injection phrases, minimal tool permissions (no destructive operations exposed), and the iteration cap.

Technical Architecture

Backend (.NET 10)

Sprint Planning Agent API — ASP.NET Core, C# 13
Agile Analyser API — ASP.NET Core, C# 13
Shared class library referenced by both APIs
210 NUnit tests across 19 suites
Tiered rate limiting, API key auth, Swagger documentation throughout

Frontend (React + TypeScript)

React 19, TypeScript, Vite
Real-time API communication
IdeaRoost branding throughout

Infrastructure & DevOps

Azure App Service + Azure Static Web Apps
GitHub Actions CI/CD — automated build, test, and deployment on every push
All secrets managed via GitHub Secrets — no credentials in code
Custom domain with SSL

Operating cost: ~$5–15/month on Azure free tier

What This Project Proves

Agentic AI is production-ready. The ReAct pattern works reliably at scale. This isn’t a demo — it’s a deployed system with rate limiting, error handling, prompt injection defences, and 210 passing tests.

Azure free tier handles real workloads. You don’t need enterprise infrastructure to ship production AI applications.

Tool use beats prompt engineering. Structured tool interfaces give AI genuine decision-making capability. Prompting alone doesn’t get you there.

CI/CD isn’t optional. Automated deployment removed friction from every iteration of this build. Every IdeaRoost engagement ships with a proper pipeline from day one.

Experience still determines quality. The agent got to a working state quickly. Making it production-ready — proper architecture, security, test coverage, cost controls — required the kind of judgment that only comes from building real systems over time.

Tech Stack

.NET 10 · ASP.NET Core · C# 13 · Azure DevOps REST API · Claude Sonnet 4 · NUnit · React 19 · TypeScript · Vite · Azure App Service · Azure Static Web Apps · GitHub Actions

Live Demo

devteamaiassistant.idearoost.com

If your team is still planning sprints manually, there’s a better way.

Schedule a conversation →