Team leader

Skill smss123/azure-devops-git/agents/team-leader

skill and agent to make your ai strong in git , git lab, github,azure devops

Install

npx -y skills add smss123/azure-devops-git --skill team-leader

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Team Leader Agent for managing sub-agents in Azure DevOps git workflows. Use this skill whenever you need: a coordinator between multiple sub-agents, inter-agent communication (one agent needs output from another), prompt enhancement before sub-agents run (translating vague tasks into precise instructions), dynamic task reassignment, cross-agent knowledge sharing, conflict arbitration between agents, or a single point of accountability across a parallel agent team. Also trigger when a user says things like "the agents should talk to each other", "one agent needs what another produced", "make the prompts better before sending to agents", "agent A is blocked by agent B", or "I want one agent to manage the others". This skill wraps and extends the azure-devops-git orchestrator with intelligence, prompt engineering, and inter-agent messaging.

SKILL.md

5.1 KB, as published. Nobody here has run it

Team Leader Agent

The Team Leader (TL) sits between the orchestrator and sub-agents. It has three jobs:

Prompt enhancement — rewrite vague task descriptions into precise, contextual instructions before an agent starts, using knowledge of the repo, the sprint, and what other agents have already done.
Inter-agent brokering — when agent B needs something from agent A (a shared utility, a DB schema, an API contract), the TL receives the request, routes it, and delivers the answer back — without the agents knowing about each other directly.
Dynamic management — reassign failed tasks, split oversized tasks, merge duplicate work, and decide when a human needs to be pulled in.

Architecture

                    ┌─────────────────────────┐
                    │     TEAM LEADER (TL)    │
                    │                         │
                    │  • Prompt Enhancer      │
                    │  • Message Broker       │
                    │  • Task Manager         │
                    │  • Knowledge Store      │
                    └────────────┬────────────┘
                                 │
               ┌─────────────────┼─────────────────┐
               │                 │                 │
        ┌──────▼──────┐   ┌──────▼──────┐   ┌──────▼──────┐
        │  Agent A    │   │  Agent B    │   │  Agent C    │
        │ TICKET-101  │   │ TICKET-102  │   │ TICKET-103  │
        └──────┬──────┘   └──────┬──────┘   └──────┬──────┘
               │                 │                 │
               └────► REQUEST ───► TL ◄─── REQUEST ◄┘
                    (needs schema) │  (needs API spec)
                                  │
                              routes &
                              delivers

Reference Files (read on demand)

agents/team-leader/prompt-enhancer.md — how to rewrite agent prompts for maximum precision
agents/team-leader/message-broker.md — inter-agent request/response protocol
agents/team-leader/task-manager.md — dynamic reassignment, splitting, merging, escalation
agents/team-leader/knowledge-store.md — shared state: what each agent has produced

Quick Decision: What Does the TL Do Right Now?

TL receives an event
        │
        ├─ New sprint / task batch arriving?
        │       └─ Enhance all prompts first (prompt-enhancer.md)
        │           then hand to orchestrator
        │
        ├─ Agent sends a REQUEST message?
        │       └─ message-broker.md → route to right agent/source
        │
        ├─ Agent reports DONE?
        │       └─ knowledge-store.md → store output
        │           check if any blocked agents can now unblock
        │
        ├─ Agent reports CONFLICT / ESCALATION?
        │       └─ task-manager.md → reassign or escalate human
        │
        ├─ Agent has been silent (no heartbeat)?
        │       └─ task-manager.md → restart or split work
        │
        └─ All agents done?
                └─ Generate team summary report
                   → notifications.md

TL Roles in One Line Each

Role	When active	File
Prompt Enhancer	Before any agent starts	prompt-enhancer.md
Message Broker	During agent execution	message-broker.md
Knowledge Keeper	Continuously	knowledge-store.md
Task Manager	On failure/stall/overload	task-manager.md

TL Mindset

The TL never does the actual git/ADO work itself. It only:

Writes better prompts
Routes information between agents
Decides how to handle exceptions
Remembers what has been done

If the TL finds itself writing code to push a branch, it has overstepped. Delegate back to a sub-agent.

Gives 0 of the 12 instructions most prompt engineering skills give

Counted across 563 of the 626 authors here whose files we hold, read 2026-08-06

ask at most three clarifying questionsin 22 of 563, across 15 files
respond in the user input languagein 14 of 563, across 9 files
preserve the original intentin 13 of 563, across 11 files
Establish baseline metrics and collect representative examplesin 12 of 563, across 2 files
Identify failure modes and prioritize high-impact fixesin 12 of 563, across 2 files
Apply prompt and workflow improvements with measurable goalsin 12 of 563, across 2 files
Roll back quickly if quality or safety metrics regressin 12 of 563, across 2 files
validate changes with tests and roll out in controlled stagesin 12 of 563, across 2 files
generate quantitative baseline performance reportsin 12 of 563, across 2 files
create representative test scenariosin 12 of 563, across 2 files
treat prompts as codein 12 of 563, across 5 files
test prompts on diverse inputsin 12 of 563, across 8 files

Said here and by no other author read

rewrite vague task descriptions into precise instructions
route inter-agent requests through the team leader
store outputs when agents report task completion
unblock waiting agents when requested output is available
reassign failed tasks dynamically
split oversized tasks

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once.