draft-project-charter

Draft a project charter that defines scope, stakeholders, success criteria, and initial risk register. Covers problem statement, RACI matrix, milestone planning, and scope boundaries for both agile and classic methodologies. Use when kicking off a new project or initiative, formalizing scope after an informal start, aligning stakeholders before detailed planning begins, or transitioning from discovery to active project work.

9 stars

Best use case

draft-project-charter is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Draft a project charter that defines scope, stakeholders, success criteria, and initial risk register. Covers problem statement, RACI matrix, milestone planning, and scope boundaries for both agile and classic methodologies. Use when kicking off a new project or initiative, formalizing scope after an informal start, aligning stakeholders before detailed planning begins, or transitioning from discovery to active project work.

Teams using draft-project-charter should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/draft-project-charter/SKILL.md --create-dirs "https://raw.githubusercontent.com/pjt222/agent-almanac/main/i18n/caveman-lite/skills/draft-project-charter/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/draft-project-charter/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How draft-project-charter Compares

Feature / Agentdraft-project-charterStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Draft a project charter that defines scope, stakeholders, success criteria, and initial risk register. Covers problem statement, RACI matrix, milestone planning, and scope boundaries for both agile and classic methodologies. Use when kicking off a new project or initiative, formalizing scope after an informal start, aligning stakeholders before detailed planning begins, or transitioning from discovery to active project work.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Draft a Project Charter

Creates a structured project charter that sets project boundaries, stakeholder agreements, and success criteria before detailed planning begins. Produces a document covering scope, RACI assignments, milestone planning, and an initial risk register for agile, classic, or hybrid methodologies.

## When to Use

- Kicking off a new project or initiative
- Formalizing scope after an informal project start
- Aligning stakeholders before detailed planning begins
- Creating a reference document for scope decisions during execution
- Transitioning from discovery to active project work

## Inputs

- **Required**: Project name and brief description
- **Required**: Primary stakeholder or sponsor
- **Optional**: Existing documentation (proposals, briefs, emails)
- **Optional**: Known constraints (budget, deadline, team size)
- **Optional**: Methodology preference (agile, classic, hybrid)

## Procedure

### Step 1: Gather Project Context and Create Charter Template

Read existing documentation (proposals, emails, briefs) to understand the project background. Identify the core problem or opportunity the project addresses. Create the charter file with a structured template to populate in later steps.

Create a file named `PROJECT-CHARTER-[PROJECT-NAME].md` with this template:

```markdown
# Project Charter: [Project Name]
## Document ID: PC-[PROJECT]-[YYYY]-[NNN]

### 1. Problem Statement
[2-3 sentences describing the problem or opportunity this project addresses]

### 2. Project Purpose
[What the project will achieve and why it matters]

### 3. Scope
#### In Scope
- [Deliverable 1]
- [Deliverable 2]

#### Out of Scope
- [Exclusion 1]
- [Exclusion 2]

### 4. Deliverables
| # | Deliverable | Acceptance Criteria | Target Date |
|---|------------|---------------------|-------------|
| 1 | | | |

### 5. Stakeholders & RACI
| Stakeholder | Role | D1 | D2 | D3 |
|-------------|------|----|----|-----|
| | | | | |

*R=Responsible, A=Accountable, C=Consulted, I=Informed*

### 6. Success Criteria
| # | Criterion | Measure | Target |
|---|-----------|---------|--------|
| 1 | | | |

### 7. Milestones
| Milestone | Target Date | Dependencies |
|-----------|-------------|--------------|
| | | |

### 8. Risk Register
| ID | Risk | Likelihood | Impact | Severity | Mitigation | Owner |
|----|------|------------|--------|----------|------------|-------|
| R1 | | | | | | |

*Likelihood/Impact: Low, Medium, High*
*Severity = Likelihood × Impact*

### 9. Assumptions and Constraints
#### Assumptions
- [Key assumption 1]

#### Constraints
- [Key constraint 1]

### 10. Approval
| Role | Name | Date |
|------|------|------|
| Sponsor | | |
| Project Lead | | |
```

Fill in the document ID using format PC-[PROJECT]-[YYYY]-[NNN] (e.g., PC-WEBSITE-2026-001). Write a problem statement (2-3 sentences) describing the current situation, the gap, and the impact. Write a project purpose statement (1 paragraph) explaining what will be achieved.

**Got:** Charter file created with document ID, problem statement, and purpose filled in. Problem statement is specific and describes a measurable gap.

**If fail:** If project context is unclear, document specific questions for the sponsor in a QUESTIONS section at the top of the charter. If existing docs conflict, note contradictions in an OPEN ISSUES section and flag for stakeholder resolution.

### Step 2: Define Scope Boundaries

Create explicit lists of what is and is not included in the project scope. Write 3-5 in-scope deliverables with specific acceptance criteria for each. Write 3-5 out-of-scope items to prevent scope creep. Populate the Deliverables table with each deliverable, its acceptance criteria, and a target date.

**Got:** Scope section has balanced in-scope and out-of-scope lists. Deliverables table contains 3-5 entries with specific, testable acceptance criteria. Target dates are realistic and sequenced logically.

**If fail:** If deliverables are vague, break down each into sub-deliverables with concrete outputs. If acceptance criteria are missing, ask: "How would we demonstrate this deliverable is complete?" If target dates are unavailable, mark as TBD and flag for milestone planning session.

### Step 3: Identify Stakeholders and Assign RACI

List all individuals or groups who will be affected by, contribute to, or have decision authority over the project. Include their organizational role. Create a RACI matrix mapping each stakeholder to each deliverable using:
- **R** (Responsible): Does the work
- **A** (Accountable): Final decision authority (only one A per deliverable)
- **C** (Consulted): Provides input before decisions
- **I** (Informed): Kept updated on progress

Ensure each deliverable has exactly one A and at least one R.

**Got:** Stakeholders table lists 5-10 people with their roles. RACI matrix has one A per deliverable column. No deliverable is missing an R or has multiple As. Sponsor is A for final approval.

**If fail:** If stakeholder list is incomplete, cross-reference with organization chart and meeting attendees from discovery phase. If multiple As are identified, escalate the conflict to the sponsor for decision authority clarification. If no R exists, flag deliverable as unassigned and requiring resource allocation.

### Step 4: Define Success Criteria and Milestones

Write 3-5 measurable success criteria using SMART format (Specific, Measurable, Achievable, Relevant, Time-bound). Each criterion should tie to a quantifiable measure and target value. Define 4-6 key milestones representing major project stages or deliverable completions, with target dates and dependencies on prior milestones.

**Got:** Success Criteria table has 3-5 entries with specific measures (e.g., "System uptime" measured as "% availability" with target "99.5%"). Milestones table shows logical project phases with realistic target dates. Dependencies are clearly noted.

**If fail:** If success criteria are vague (e.g., "improve quality"), rewrite as measurable outcomes with baseline and target values. If milestone dates are unrealistic, work backward from final deadline using estimated durations and buffers. If dependencies create circular logic, restructure milestone sequence or split conflicting milestones.

### Step 5: Create Initial Risk Register

Identify 5-10 risks that could impact project success. For each risk, assess likelihood (Low/Medium/High) and impact (Low/Medium/High), then calculate severity. Define a specific mitigation strategy for each risk and assign a risk owner responsible for monitoring and response. Include at least one risk in each category: scope, schedule, resource, technical, and external.

**Got:** Risk Register has 5-10 entries covering scope, schedule, resource, technical, and external risks. Each risk has likelihood, impact, and severity assessed. Mitigation strategies are actionable and specific. Each risk has an assigned owner.

**If fail:** If risk list is incomplete, review scope boundaries, dependencies, stakeholder list, and assumptions for potential failure points. If mitigation strategies are generic ("monitor closely"), specify: What will be monitored? How often? What triggers action? If no one accepts risk ownership, assign to project lead temporarily and escalate to sponsor.

## Validation

- [ ] Charter file created with document ID
- [ ] Problem statement is specific and measurable
- [ ] Scope has both in-scope and out-of-scope items
- [ ] RACI matrix covers all deliverables
- [ ] Success criteria are measurable (SMART)
- [ ] At least 5 risks identified with mitigation strategies
- [ ] Milestones have target dates
- [ ] Approval section included

## Pitfalls

- **Scope without boundaries**: Listing in-scope items without explicit out-of-scope items leads to scope creep. Define what you won't do.
- **Vague success criteria**: "Improve performance" is unmeasurable. Tie every criterion to a number with a baseline and target.
- **Missing stakeholders**: Overlooked stakeholders surface late and derail the project. Cross-reference org charts and prior project communications.
- **Risk register as checkbox**: Listing risks without actionable mitigation plans provides false confidence. Each risk needs a specific response strategy.
- **Over-detailed charter**: The charter is a compass, not a map. Keep it to 2-4 pages. Detailed planning happens later.

## Related Skills

- `create-work-breakdown-structure` — decompose charter deliverables into work packages
- `manage-backlog` — translate charter scope into a prioritized backlog
- `plan-sprint` — plan the first sprint from charter deliverables
- `generate-status-report` — report progress against charter milestones
- `conduct-retrospective` — review charter assumptions after execution

Related Skills

tidy-project-structure

9
from pjt222/agent-almanac

Organize project files into conventional directories, update stale READMEs, clean configuration drift, and archive deprecated items without changing code logic. Use when files are scattered without clear organization, READMEs are outdated or contain broken examples, configuration files have multiplied across dev/staging/prod, deprecated files remain in the project root, or naming conventions are inconsistent across directories.

setup-gxp-r-project

9
from pjt222/agent-almanac

Set up an R project structure compliant with GxP regulations (21 CFR Part 11, EU Annex 11). Covers validated environments, qualification documentation, change control, and electronic records requirements. Use when starting an R analysis project in a regulated environment (pharma, biotech, medical devices), setting up R for clinical trial analysis, creating a validated computing environment for regulatory submissions, or implementing 21 CFR Part 11 or EU Annex 11 requirements.

polish-claw-project

9
from pjt222/agent-almanac

Contribute to OpenClaw ecosystem projects (OpenClaw, NemoClaw, NanoClaw) through a structured 9-step workflow: target verification, codebase exploration, parallel audit, finding cross-reference, and pull request creation. Emphasizes false positive prevention and project convention adherence.

cross-review-project

9
from pjt222/agent-almanac

Conduct a structured cross-project code review between two Claude Code instances via the cross-review-mcp broker. Each agent reads its own codebase, reviews the peer's code, and engages in evidence-backed dialogue — with QSG scaling laws enforcing review quality through minimum bandwidth constraints and phase-gated progression.

skill-name-here

9
from pjt222/agent-almanac

One to three sentences describing what this skill accomplishes, followed by key activation triggers. This field is the primary mechanism agents use to decide whether to activate the skill — it is read during discovery before the full body is loaded. Start with a verb. Include the most important "when to use" conditions inline. Max 1024 characters.

write-vignette

9
from pjt222/agent-almanac

Create R package vignettes using R Markdown or Quarto. Covers vignette setup, YAML configuration, code chunk options, building and testing, and CRAN requirements for vignettes. Use when adding a Getting Started tutorial, documenting complex workflows spanning multiple functions, creating domain-specific guides, or when CRAN submission requires user-facing documentation beyond function help pages.

write-validation-documentation

9
from pjt222/agent-almanac

Write IQ/OQ/PQ validation documentation for computerized systems in regulated environments. Covers protocols, reports, test scripts, deviation handling, and approval workflows. Use when validating R or other software for regulated use, preparing for a regulatory audit, documenting qualification of computing environments, or creating and updating validation protocols and reports for new or re-qualified systems.

write-testthat-tests

9
from pjt222/agent-almanac

Write comprehensive testthat (edition 3) tests for R package functions. Covers test organization, expectations, fixtures, mocking, snapshot tests, parameterized tests, and achieving high coverage. Use when adding tests for new package functions, increasing test coverage for existing code, writing regression tests for bug fixes, or setting up test infrastructure for a package that lacks it.

write-standard-operating-procedure

9
from pjt222/agent-almanac

Write a GxP-compliant Standard Operating Procedure (SOP). Covers regulatory SOP template structure (purpose, scope, definitions, responsibilities, procedure, references, revision history), approval workflow design, periodic review scheduling, and operational procedures for system use. Use when a new validated system requires operational procedures, when existing informal procedures need formalisation, when an audit finding cites missing procedures, when a change control triggers SOP updates, or when periodic review identifies outdated procedural content.

write-roxygen-docs

9
from pjt222/agent-almanac

Write roxygen2 documentation for R package functions, datasets, and classes. Covers all standard tags, cross-references, examples, and generating NAMESPACE entries. Follows tidyverse documentation style. Use when adding documentation to new exported functions, documenting internal helpers or datasets, documenting S3/S4/R6 classes and methods, or fixing documentation-related R CMD check notes.

write-incident-runbook

9
from pjt222/agent-almanac

Create structured incident runbooks with diagnostic steps, resolution procedures, escalation paths, and communication templates for effective incident response. Use when documenting response procedures for recurring alerts, standardizing incident response across an on-call rotation, reducing MTTR with clear diagnostic steps, creating training materials for new team members, or linking alert annotations directly to resolution procedures.

write-helm-chart

9
from pjt222/agent-almanac

Create production-ready Helm charts for Kubernetes application deployment with templating, values management, chart dependencies, hooks, and testing. Covers chart structure, Go template syntax, values.yaml design, chart repositories, versioning, and best practices for maintainable and reusable charts. Use when packaging a Kubernetes application for repeatable deployments, parameterizing manifests for multiple environments, managing complex multi-component applications with dependencies, or standardizing deployment practices with versioned rollback capability across teams.