Hire an AI launch dependency and recovery planner

Everything it can hand back

Your task sets the actual outputs. The specialist picks the methods that cover them.

• A list of parts and every join between them, with what crosses each
• A readiness score out of 100 with how it was worked out
• A priority plan for when the system is overloaded, and what it must never drop
• A run-through plan for the whole launch
• Alarm text for each mistake, the go or no-go decision it asks for and a safe restart point

How it does the job well

• Read the existing code, its conventions and its tests before changing anything. Match the project's patterns.
• Make the smallest change that fully solves the request. Keep unrelated refactors out.
• Reproduce a bug before fixing it, and add a test that fails without the fix.
• Treat input from users, files and networks as untrusted. Validate it at the boundary.

Mistakes it avoids

• Claiming code works without running it or its tests.
• Inventing APIs, package versions or settings instead of checking the installed ones.
• Changing behaviour outside the request, such as reformatting whole files or renaming public interfaces.

What a good result looks like

An example, not your task: A release or migration is coming and you want to know where it could fail before it does.

• Parts and joins. Every part with its owner, and each join between parts with what passes across it.
• Priorities and overload plan. A rank for each job, and what the system drops or must never drop when overloaded.
• Readiness score. A score out of 100 with the working shown, based on written reasons and approvals for each change.
• Run-through plan. The steps for a full rehearsal, and who reads the final package.
• Mistakes said to be impossible. Each mistake, how it would be detected, and what the system does in response.
• Alarms and safe restart. Alarm text, the go or no-go decision and who makes it, plus the safe restart point.

How the work is checked

• Every join lists what passes across it, not only that two parts are linked.
• Every job has its own priority, with no ties left to chance.
• The readiness score says what it measures and how it was worked out.
• Each alarm names the decision the person has to make.
• States which checks passed, failed or could not run, and names missing inputs.

These checks have not been run against a model yet. Your AI uses them to check its own work.

A second opinion

Before it hands back, your AI reviews the draft the way Margaret Hamilton would. This is a way of reviewing the work. It does not mean they wrote or endorse it.

Capabilities

• Maps parts and joins. Lists every part, including people and plans, and marks each join and what passes across it.
• Sets priorities. Gives each job its own priority and decides what the system drops and what it must never drop when overloaded.
• Scores readiness. Checks that every change has a written reason and an approval, and gives a readiness score with the working shown.
• Designs the alarms. Takes the gaps from the check and writes an alarm for each mistake, with the decision it asks for, go or no-go.
• Plans the recovery. Sets a safe restart point, the jobs that keep running and a review of each error by kind afterwards.

How the role works

1. Checks your task, context and available tools.
2. Picks the methods needed and prepares a work plan.
3. Carries out supported tasks, with each method's limits and review gates.
4. Checks the real deliverables and corrects supported faults.
5. Hands back files, evidence and unresolved gaps.

Your specialist's working setup

Download the base specialist without a task form or account. README.md and SETUP.md explain how to use the folder. SOUL.md defines its scope. INTAKE.md asks missing questions inside your AI. PLAYBOOK.md, SKILLS.md, BEST_PRACTICES.md, CHECKS.md and HANDOFF.md guide the work and its checked deliverables.

Complete associated skills, supporting files and licences are included. Choose only the methods needed for the actual task. Keep context, working files and accepted feedback in your AI project.

Use this specialist through MCP or the API

Call prepare_specialist with role_id launch-risk-check only. No task is required to load it. Your AI asks what job you need done, what you want back and which relevant context it can use.

For task-led hiring, call find_specialist, explain the suggested specialists and let the user accept or change the team.

Complete ZIP: Download base specialist. API: GET /api/v1/specialists/launch-risk-check/pack. The host AI supplies its own model, tools and execution; a pack does not connect accounts or run a task.

Inputs and helpful context

The specialist starts from the task brief. Only active methods require their inputs.

For the primary method, when used

• What is launching, the date and what success looks like
• The parts, teams and suppliers involved, as far as you know them
• Change records, plans or earlier problems (optional)
• The mistakes people on your team say can't happen (optional)

Tools and access

• Any good chat AI: Tracing joins and writing a plan from a description is text work any strong chat AI does.
• A whiteboard or diagram tool: Drawing the parts and arrows makes missing joins easy to see.
• Any good chat AI: Listing failures and writing alarm text is text work any strong chat AI does.
• Your alert or paging tool: The alarms it writes still have to be set up where your people will see them.

Functions and deliverables

• Launch dependency and recovery planner: Describe a release, its parts and failure risks. Get handoff checks, overload priorities, warning messages and a recovery plan.
  • A list of parts and every join between them, with what crosses each
  • A readiness score out of 100 with how it was worked out
  • A priority plan for when the system is overloaded, and what it must never drop
  • A run-through plan for the whole launch
  • Alarm text for each mistake, the go or no-go decision it asks for and a safe restart point
• Launch readiness checker: Describe a launch, migration or release. Get a readiness score, the joins between parts and a run-through plan.
  • A list of parts and every join between them, with what crosses each
  • A readiness score out of 100 and how it was worked out
  • The priority and overload plan, and gaps in change control
  • A run-through plan and who reads the final package
• Error alarms and recovery planner: Plan how a system spots mistakes and helps people recover. Get clear alarms, who must act and checks for a safe restart.
  • A list of can't-happen mistakes with how each is detected and what the system does
  • A safe restart point and the jobs kept running
  • The alarm text, with the decision it asks for
  • A plan to review errors by kind
• Agent delegation and dependency planner: Plan which AI agent owns each task, who may hand work to whom and what must finish first. Get a delegation plan and failure test cases.
  • A delegation plan: for each handoff, who gets it, why, what they may do and what it waits for
  • An authority and depth check, listing any handoff that would be refused
  • What is logged for each handoff and each refusal
  • A failure checklist
  • Test cases using made-up agents and tasks
  • A list of missing inputs and checks that did not run
• AI project context organiser: Share your project and next task. Get a short rules file, a focused file list and a clear handoff for later sessions.
  • A ready rules file for your project
  • A list of which files to load for each task
  • Rules for when to reset or trim the session
  • A checklist for spotting drifting answers
  Source: Addy Osmani.
• Margaret Hamilton: Review a system failure plan using Margaret Hamilton’s recorded approach. Check handoffs, priorities, warnings and what happens when people make mistakes.
  • Your problem worked on the way Margaret Hamilton would: their questions, their method, their push-back
  • The answer or the work, in Margaret Hamilton's voice, using their ideas by name
  • Anything that goes beyond their public record, marked
  • One suggested next step

Tasks you can use it for

• A release or migration is coming and you want to know where it could fail before it does.
• Your last launch went wrong at a handoff between teams or tools, and you want to stop that happening again.
• You are adding a new system to a busy one and need to know what happens when everything runs at once.

Limits to check before starting

• You change one system with one owner: use a plain test plan and a rollback note instead.
• You need a project schedule or task list: use a project planning tool or ask a project manager.
• You want to design code changes after the check: use the Process and behavior change planner once you have the plan.

Best way to use this role

Give it one clear outcome, the actual files and a definition of done. Keep the work in one AI project so it can reuse checked context and earlier files.

• Download the handoff pack first. It's a zip with HANDOFF.md and the two skill files this workflow uses, the launch readiness seam checker and the error warning and recovery designer.
• Give the folder to Claude (in Claude Code, or as files in a Claude Project) and say "Follow HANDOFF.md".
• Describe the launch and list the parts you know about. It works step by step and saves each result.
• Do the run-through with a person in the loop before the real launch, and fix what it finds.

Read it as data

Read the complete role setup as JSON. Connect your AI to the AI Blocks MCP library and read aiblocks://roles/launch-risk-check for its role instructions and pinned sources.

This is a prepared AI role. No task has run. Your AI carries out authorized work using its available tools and reports the actual deliverables and checks.