Built at BetaCraft · Running on live client projects

Your PM week,
operated.

pm-* is a set of 23 Claude Code skills that run the full project-management lifecycle — call transcript to SOW, risk scan to status dashboard. You make the decisions. Claude does the paperwork.

23skills, full lifecycle
4things you still do
~20minweekly admin overhead
3live client projects
simulation — one PM week
This week's PM workload
MON
digest client call draft brief decide scope
TUE
estimate hours generate SOW client call
WED
create Jira tickets risk scan
THU
triage inbox draft replies approve & send
FRI
status dashboard meeting minutes sign off
15 tasks → 4 decisions.Everything in blue ran itself. Everything in red still needs a human — that's the point.
The deal

Four things you keep.

Automation isn't the goal — delegation is. pm-* takes the admin layer and leaves you exactly the work that needs judgement, context, and a face.

01

Decide

Scope calls, trade-offs, priorities. The skills surface options with evidence — the call is always yours.

02

Talk to humans

Client calls, standups, hard conversations. AI drafts the prep; you bring the relationship.

03

Review

Every SOW, email, and estimate lands as a draft. Nothing leaves the building without your eyes on it.

04

Sign off

Phase gates, deliverables, budgets. The system prepares the closeout — your name goes on it.

Everything else — the other ~80% of a PM's week — is handled by the 23 skills below.

How it works

Call to ticket, one chain.

Each skill produces a structured artifact the next one consumes. A raw client call becomes scoped, estimated, contracted work — without a single document written by hand.

Input

Transcript

Drop in a raw call recording transcript — Fathom, Meet, anything.

→
Skill 1

Brief

Digested into decisions, action items, and open questions. Strictly grounded — nothing inferred.

→
Skill 2

Estimate

Hour estimates per workstream, calibrated against past project actuals.

→
Skill 3

SOW

A client-ready statement of work — scope, phases, assumptions, exclusions.

→
Skill 4

Jira

Epics and tickets generated via MCP, mapped to the SOW line items.

→
Output

Dashboard

A live status page the client can actually read. Auto-refreshed weekly.

One chain of many — risk, comms, and closeout run their own.

The catalog

23 skills, 5 stages.

Every skill is a Claude Code workflow with a natural-language trigger. They share project context, write structured artifacts, and chain into each other.

pm-digest-callIntake

Turns a raw transcript into decisions, action items, and open questions — strictly grounded, nothing inferred.

pm-intakeIntake

Structured project intake — captures client context, constraints, and success criteria into a project brief.

pm-analyze-emailIntake

Parses long client email threads into asks, blockers, and required responses.

pm-requirementsIntake

Extracts and normalizes requirements from mixed sources — calls, docs, chat — with source references.

pm-context-loadIntake

Loads full project context into a session so every other skill works with current state, not stale memory.

pm-estimateScope

Hour estimates per workstream, calibrated against past project actuals and team velocity.

pm-sowScope

Generates a client-ready statement of work — scope, phases, assumptions, exclusions, payment terms.

pm-sow-alignScope

Diffs delivered work against the signed SOW and flags drift before it becomes a dispute.

pm-sprint-planScope

Builds sprint plans with capacity math, dependencies, and screen-by-screen source fidelity.

pm-scope-changeScope

Processes change requests — impact assessment, revised estimate, and a client-facing summary.

pm-jiraDelivery

Generates epics and tickets via MCP, mapped one-to-one against SOW line items.

pm-risk-scanDelivery

Weekly scan across tickets, comms, and budget burn — surfaces risks before they surface themselves.

pm-standupDelivery

Compiles async standup digests from Jira activity and Slack threads.

pm-dashboardDelivery

Publishes a live status dashboard the client can actually read. Auto-refreshed weekly.

pm-blockerDelivery

Tracks blockers with owners and aging — escalates anything stuck past its threshold.

pm-decision-logDelivery

Maintains an append-only decision log with date, context, and who signed off.

pm-client-emailComms

Drafts client emails in your voice and register — updates, escalations, difficult news.

pm-momComms

Formal minutes of meeting with strict factual grounding — no inferred content, ever.

pm-weekly-updateComms

Assembles the weekly client update from dashboard data, decision log, and sprint state.

pm-escalationComms

Structures escalations with evidence trails — transcript quotes, ticket links, dates.

pm-phase-closeCloseout

Phase closeout package — deliverable checklist, acceptance evidence, sign-off doc.

pm-retroCloseout

Runs a structured retro from sprint data — what slipped, what worked, what changes next sprint.

pm-handoverCloseout

Generates handover documentation so a project can change hands without losing context.

Skill names and descriptions shown are representative. Each skill lives in its own folder with a SKILL.md, triggers on natural language, and was built using the vibe-* development framework.

Install

Two minutes to running.

# clone into your Claude Code skills directory
git clone https://github.com/aakashdhar/pm-skills.git ~/.claude/skills/pm
 
# open any project and just talk
claude
> digest this call transcript and draft the SOW
  • Claude Code — the skills are plain markdown workflows; no build step, no dependencies.
  • Your project folder — skills read and write structured artifacts next to your code.
  • Optional MCPs — connect Jira, Gmail, or Slack and the delivery skills go fully hands-off.
  • Distribution is git clone — fork it, strip what you don't need, make it yours.
FAQ

Straight answers.

What is pm-*?

A set of 23 Claude Code skills that automate the project management admin layer — turning call transcripts into briefs, briefs into estimates and SOWs, SOWs into Jira tickets, and project state into client-ready dashboards and updates. The PM keeps decisions, client conversations, reviews, and sign-offs.

What do I need to run it?

Only Claude Code. The skills are plain markdown workflows — no build step, no dependencies. Optionally, connect Jira, Gmail, or Slack via MCP and the delivery skills go fully hands-off. Install is a single git clone.

Is it free?

Yes. Distribution is git clone. Fork it, strip what you don't need, adapt it to your own workflow.

Does the AI send anything to clients without review?

No. Every SOW, email, estimate, and document lands as a draft for your review. The system is built around delegation, not autonomy — deciding, talking to humans, reviewing, and signing off always stay with you.

Who built this?

Aakash Dhar — Technical Project Manager at BetaCraft, 8.5 years a developer before that. pm-* is the operational sibling of vibe-*, his 26-skill development framework for Claude Code, and runs on live client projects at BetaCraft today.

Built by a PM
who codes.

I'm Aakash Dhar — Technical Project Manager at BetaCraft, 8.5 years a developer before that. pm-* exists because I got tired of spending my week on documents a machine should write.

It now runs the PM admin layer across three live client engagements. It's the operational sibling of vibe-*, my 26-skill development framework for Claude Code.

Get pm-* → See vibe-* Full portfolio