A greenfield, modular library of composable, general-purpose Agent Skills for LLM-driven automation and workflow orchestration.
Build reusable, parameterized skills that can be easily composed into higher-level workflows. All skills are designed for LLM agent invocation, enabling sophisticated automation through simple composition.
Skills can be invoked directly or composed into workflows:
# Direct skill invocation
"Analyze this codebase using parallel-execution"
# Workflow composition
"Process PR #42 end-to-end" (uses process-pr workflow)
- Execution: Control flow and task orchestration
- Tools: Concrete integrations (GitHub, APIs, etc.)
- Interaction: Human-agent collaboration patterns
- Workflow: Composed, domain-specific automations
All skills are atomic or composable, enabling flexible workflow construction.
workflow: process-pr
├─ parallel-execution (assess PR readiness)
├─ resolve-pr-comments (address feedback)
└─ merge-pr (safe merge execution)
Skills accept parameters for maximum reuse across contexts.
parallel-execution:
- tasks: [task1, task2, task3]
- execution-mode: concurrent
yolo:
- confidence-threshold: 0.7
- max-retries: 3General skills (parallel-execution, tool invocation) separate from workflow-specific skills (process-pr).
Each skill includes comprehensive SKILL.md with parameters, usage examples, and composition patterns.
All skills designed for natural language invocation and chaining by LLM agents.
pax/
├── docs/ # Documentation
│ ├── README.md # This file
│ ├── GETTING_STARTED.md # Quick start guide
│ ├── SKILL_COMPOSITION.md # Composition patterns
│ └── EXAMPLES.md # Real-world examples
│
├── skills/ # All skills
│ ├── execution/ # Execution patterns
│ │ ├── parallel-execution/
│ │ │ └── SKILL.md
│ │ └── sequential-execution/
│ │ └── SKILL.md
│ │
│ ├── tools/ # Tool integrations
│ │ └── pull-request-tool/
│ │ └── SKILL.md
│ │
│ ├── interaction/ # Agent-human interaction
│ │ ├── yolo/
│ │ │ └── SKILL.md
│ │ └── collaborative/
│ │ └── SKILL.md
│ │
│ └── workflow/ # Composed workflows
│ ├── resolve-pr-comments/
│ │ └── SKILL.md
│ ├── merge-pr/
│ │ └── SKILL.md
│ └── process-pr/
│ └── SKILL.md
│
└── SKILL_LIBRARY_PLAN.md # Original plan
Execute multiple independent tasks simultaneously for maximum efficiency.
When to use: Multiple analyses, independent file processing, concurrent reviews
Example:
"Analyze security, performance, and testing in parallel"
Execute dependent tasks in order where each task relies on previous results.
When to use: Build pipelines, ordered workflows, dependent steps
Example:
"Process PR: fetch → test → review → merge"
Unified entry point for all GitHub pull request and issue management. Automatically selects the best backend (Copilot API or CLI) for the environment.
When to use: Any PR/issue management, review, comment, or merge operation—always start here for maximum compatibility and future-proofing.
Note: You may also invoke as pr-tool (see SKILL.md for details).
Example:
"Merge PR #42 using pull-request-tool"
Manage GitHub pull requests and issues using Copilot's built-in PR/issue APIs. Provides structured, agent-native operations for review, comment, resolve, and merge workflows.
When to use: In Copilot agent environments (VS Code, Copilot CLI, etc.) for maximum integration and reliability.
Example:
"Fetch PR #42 details using copilot-pull-request"
Interact with GitHub pull requests for review, comment management, and merge operations via the GitHub CLI. Used as a backend by the wrapper when Copilot APIs are unavailable.
When to use: CLI environments, or as a fallback for PR/issue management.
Example:
"Get all unresolved comments on PR #42"
Autonomous "just do it" mode - execute actions without confirmation.
When to use: Well-defined workflows, time-critical operations, low-risk automation
Example:
"Process all approved PRs in YOLO mode"
Human-in-the-loop interaction with confirmations and feedback.
When to use: High-risk operations, ambiguous requirements, learning scenarios
Example:
"Let's review and merge PR #42 together"
Systematically address and resolve pull request review comments.
Composes: pull-request-tool + sequential-execution + (yolo OR collaborative)
Example:
"Resolve all PR comments on #42"
Safely merge pull requests after comprehensive verification.
Composes: pull-request-tool + sequential-execution + (yolo OR collaborative)
Example:
"Merge PR #42 after verifying all checks pass"
End-to-end PR processing from review to merge.
Composes: parallel-execution + sequential-execution + pull-request-tool + resolve-pr-comments + merge-pr + (yolo OR collaborative)
Example:
"Process PR #42 from start to finish"
process-pr:
Step 1: Assess (parallel)
Step 2: Verify (sequential)
Step 3: Resolve (sequential)
Step 4: Merge (sequential)codebase-review:
Parallel:
- Security analysis
- Performance analysis
- Test coverage analysis
Then:
- Synthesize findingsAny workflow:
IF user wants autonomous → use yolo
IF user wants interactive → use collaborativepull-request-tool (tool):
Canonical entry point for all PR/issue management
Delegates to:
- copilot-pull-request (API backend)
- gh-pr-review (CLI backend)
Used by:
- resolve-pr-comments
- merge-pr
- process-prUser: "Process PR #42 in YOLO mode"
Execution:
- process-pr skill
- Mode: yolo
- Steps:
1. Parallel assessment (PR status + reviews + CI)
2. Run local tests
3. Resolve 3 comments automatically
4. Wait for CI to pass
5. Verify approvals
6. Merge with squash
7. Delete branch
Output: "PR #42 merged successfully"User: "Process all approved PRs"
Execution:
- List approved PRs: #41, #42, #43
- parallel-execution spawns:
- process-pr(#41, yolo)
- process-pr(#42, yolo)
- process-pr(#43, yolo)
- Each runs independently
- Report: "3 PRs processed and merged"User: "Help me review and merge PR #42"
Execution:
- process-pr skill
- Mode: collaborative
- Interactive steps with user approval at each stage
- User makes decisions on ambiguous items
- Agent executes approved actions- Choose category: execution, tools, interaction, or workflow
- Create directory:
skills/<category>/<skill-name>/ - Write SKILL.md: Follow existing format
- Document:
- Purpose and when to use
- Parameters
- Usage examples
- Composition patterns
- Test: Verify skill works in isolation and composition
---
name: skill-name
description: One-line description
category: execution|tools|interaction|workflow
license: MIT
composed-from: [optional list of skills this composes]
---
# Skill Name
Description and purpose.
## When to Use
Specific scenarios...
## Parameters
Required and optional parameters...
## Usage Examples
Concrete examples...
## Quick Reference
Cheat sheet...- Start with general skills: Use execution and tool skills
- Compose into workflows: Build domain-specific workflows
- Choose interaction mode: yolo for automation, collaborative for oversight
- Leverage parallelism: Use parallel-execution when tasks independent
- Document decisions: Explain choices in skill outputs
- Handle errors gracefully: Implement proper error recovery
- Test composition: Verify skills work together correctly
- Use parallel-execution for independent tasks: 3-10x faster
- Use yolo mode for well-defined workflows: No confirmation delays
- Use sequential-execution only when dependencies exist
- Batch process multiple items with parallel-execution
- Fork the repository
- Create skill in appropriate category
- Follow SKILL.md template
- Add to this README
- Submit PR with examples
MIT License - See individual skills for details
- Documentation: docs/
- Examples: docs/EXAMPLES.md
- Composition Guide: docs/SKILL_COMPOSITION.md
- Core execution skills (parallel, sequential)
- GitHub PR tools
- Interaction modes (yolo, collaborative)
- PR workflows (resolve, merge, process)
- Additional tool integrations (Jira, Slack, etc.)
- More workflow patterns
- Skill discovery and search
- Validation and testing framework