@forwardimpact/pathway 0.1.0 → 0.2.0

package/examples/capabilities/people.yaml

@@ -1,3 +1,5 @@
+# yaml-language-server: $schema=https://schema.forwardimpact.team/json/capability.schema.json
+
 name: People
 emoji: 👥
 displayOrder: 6
@@ -5,40 +7,6 @@ description: |
   Growing individuals and building effective teams.
   Includes mentoring, coaching, hiring, performance management,
   and creating inclusive environments.
-transitionChecklists:
-  plan_to_code:
-    foundational:
-      - Pair programming opportunities are identified
-      - Knowledge sharing approach is considered
-    working:
-      - Mentoring opportunities are planned
-      - Team learning needs are identified
-      - Collaboration approach is documented
-    practitioner:
-      - Cross-team knowledge sharing is coordinated
-      - Coaching objectives are defined
-      - Hiring needs are assessed
-    expert:
-      - Talent development strategy is aligned
-      - Leadership pipeline opportunities are identified
-      - Organizational learning goals are addressed
-  code_to_review:
-    foundational:
-      - Code review is constructive and educational
-      - Knowledge is shared during review
-      - Team standards are reinforced
-    working:
-      - Junior engineers can learn from the code
-      - Technical decisions are explained
-      - Review feedback develops others
-    practitioner:
-      - Cross-team learning is enabled
-      - Technical mentoring happens through reviews
-      - Best practices are reinforced
-    expert:
-      - Code sets example for organization
-      - Leadership behaviors are modeled
-      - Institutional knowledge is preserved
 professionalResponsibilities:
   awareness:
     Contribute positively to team dynamics, be open to feedback, and learn

package/examples/capabilities/reliability.yaml

@@ -1,3 +1,5 @@
+# yaml-language-server: $schema=https://schema.forwardimpact.team/json/capability.schema.json
+
 name: Reliability
 emoji: 🛡️
 displayOrder: 5
@@ -5,40 +7,6 @@ description: |
   Ensuring systems are dependable, secure, and observable.
   Includes DevOps practices, security, monitoring, incident response,
   and infrastructure management.
-transitionChecklists:
-  plan_to_code:
-    foundational:
-      - Security requirements are understood
-      - Operational guidelines are followed
-    working:
-      - Monitoring strategy is planned
-      - Failure modes are identified
-      - Alerting thresholds are defined
-    practitioner:
-      - SLOs/SLIs are defined for the system
-      - Incident response procedures are documented
-      - Cross-team reliability dependencies are mapped
-    expert:
-      - Reliability strategy aligns with enterprise standards
-      - Disaster recovery approach is defined
-      - Resilience patterns are specified
-  code_to_review:
-    foundational:
-      - Security guidelines are followed
-      - Basic monitoring is implemented
-      - Error logging exists
-    working:
-      - Comprehensive monitoring and alerting are in place
-      - Failure scenarios are tested
-      - Runbooks are created or updated
-    practitioner:
-      - SLOs are measurable and validated
-      - Resilience is tested (chaos engineering)
-      - Security review is completed
-    expert:
-      - Solution meets enterprise reliability standards
-      - Incident management integration is verified
-      - Disaster recovery is tested
 professionalResponsibilities:
   awareness:
     Follow security and operational guidelines, escalate issues appropriately,
@@ -107,18 +75,85 @@ skills:
         Guide for building CI/CD pipelines, managing infrastructure as code, and
         implementing deployment best practices. Use when setting up pipelines,
         containerizing applications, or configuring infrastructure.
-      body: |
-        # DevOps & CI/CD
-
-        ## When to use this skill
-
-        Use this skill when:
-        - Setting up or modifying CI/CD pipelines
-        - Containerizing applications with Docker
-        - Managing infrastructure as code
-        - Troubleshooting deployment failures
-        - Implementing monitoring and alerting
-
+      stages:
+        specify:
+          focus: |
+            Define CI/CD and infrastructure requirements.
+            Clarify deployment strategy and operational needs.
+          activities:
+            - Document deployment frequency requirements
+            - Identify rollback and recovery requirements
+            - Specify monitoring and alerting needs
+            - Define security and compliance constraints
+            - Mark ambiguities with [NEEDS CLARIFICATION]
+          ready:
+            - Deployment requirements are documented
+            - Recovery requirements are specified
+            - Monitoring needs are identified
+            - Compliance constraints are clear
+        plan:
+          focus: |
+            Plan CI/CD pipeline architecture and infrastructure requirements.
+            Consider deployment strategies and monitoring needs.
+          activities:
+            - Define pipeline stages (build, test, deploy)
+            - Identify infrastructure requirements
+            - Plan deployment strategy (rolling, blue-green, canary)
+            - Consider monitoring and alerting needs
+            - Plan secret management approach
+          ready:
+            - Pipeline architecture is documented
+            - Deployment strategy is chosen and justified
+            - Infrastructure requirements are identified
+            - Monitoring approach is defined
+        code:
+          focus: |
+            Implement CI/CD pipelines and infrastructure as code. Follow
+            best practices for containerization and deployment automation.
+          activities:
+            - Configure CI/CD pipeline stages
+            - Implement infrastructure as code (Terraform, CloudFormation)
+            - Create Dockerfiles with security best practices
+            - Set up monitoring and alerting
+            - Configure secret management
+            - Implement deployment automation
+          ready:
+            - Pipeline runs on every commit
+            - Tests run before deployment
+            - Deployments are automated
+            - Infrastructure is version controlled
+            - Secrets are managed securely
+            - Monitoring is in place
+        review:
+          focus: |
+            Verify pipeline reliability, security, and operational readiness.
+            Ensure rollback procedures work and documentation is complete.
+          activities:
+            - Verify pipeline runs successfully end-to-end
+            - Test rollback procedures
+            - Review security configurations
+            - Validate monitoring and alerts
+            - Check documentation completeness
+          ready:
+            - Pipeline is tested and reliable
+            - Rollback procedure is documented and tested
+            - Alerts are configured and tested
+            - Runbooks exist for common issues
+        deploy:
+          focus: |
+            Deploy pipeline and infrastructure changes to production.
+            Verify operational readiness.
+          activities:
+            - Deploy pipeline configuration to production
+            - Verify deployment workflows work correctly
+            - Confirm monitoring and alerting are operational
+            - Run deployment through the new pipeline
+          ready:
+            - Pipeline deployed and operational
+            - Workflows tested in production
+            - Monitoring confirms healthy operation
+            - First deployment through pipeline succeeded
+      reference: |
         ## CI/CD Pipeline Stages
 
         ### Build
@@ -176,17 +211,6 @@ skills:
         - Route small percentage to new version
         - Monitor for issues
         - Gradually increase traffic
-
-        ## DevOps Checklist
-
-        - [ ] Pipeline runs on every commit
-        - [ ] Tests run before deployment
-        - [ ] Deployments are automated
-        - [ ] Rollback procedure is documented
-        - [ ] Infrastructure is version controlled
-        - [ ] Secrets are managed securely
-        - [ ] Monitoring is in place
-        - [ ] Alerts are configured
   - id: sre_practices
     name: Site Reliability Engineering
     human:
@@ -219,18 +243,86 @@ skills:
         Guide for ensuring system reliability through observability, incident
         response, and capacity planning. Use when designing monitoring, handling
         incidents, setting SLOs, or improving system resilience.
-      body: |
-        # Site Reliability Engineering
-
-        ## When to use this skill
-
-        Use this skill when:
-        - Designing monitoring and alerting
-        - Defining SLIs, SLOs, and error budgets
-        - Handling or preparing for incidents
-        - Conducting post-mortems
-        - Planning for capacity and resilience
-
+      stages:
+        specify:
+          focus: |
+            Define reliability requirements and SLO targets.
+            Identify critical user journeys that need protection.
+          activities:
+            - Identify critical user journeys and business impact
+            - Document reliability requirements (availability, latency)
+            - Define SLO targets with stakeholder agreement
+            - Specify acceptable error budgets
+            - Mark ambiguities with [NEEDS CLARIFICATION]
+          ready:
+            - Critical user journeys are identified
+            - Reliability requirements are documented
+            - SLO targets are defined
+            - Error budgets are agreed
+        plan:
+          focus: |
+            Define reliability requirements, SLIs/SLOs, and observability
+            strategy. Plan for resilience and capacity needs.
+          activities:
+            - Define SLIs for key user journeys
+            - Set SLOs with stakeholder agreement
+            - Plan observability strategy (metrics, logs, traces)
+            - Identify failure modes and resilience patterns
+            - Define alerting thresholds
+          ready:
+            - SLIs defined for key user journeys
+            - SLOs set with stakeholder agreement
+            - Monitoring strategy is planned
+            - Failure modes are identified
+            - Alerting thresholds are defined
+        code:
+          focus: |
+            Implement observability, resilience patterns, and operational
+            tooling. Build systems that fail gracefully and recover quickly.
+          activities:
+            - Implement metrics, logging, and tracing
+            - Configure alerts based on SLOs
+            - Implement resilience patterns (timeouts, retries, circuit
+              breakers)
+            - Create runbooks for common issues
+            - Set up error budget tracking
+          ready:
+            - Comprehensive monitoring is in place
+            - Alerts are actionable and low-noise
+            - Resilience patterns are implemented
+            - Runbooks exist for common issues
+            - Error budget tracking is in place
+        review:
+          focus: |
+            Verify reliability implementation meets SLOs and operational
+            readiness. Ensure incident response procedures are in place.
+          activities:
+            - Validate SLOs are measurable
+            - Test failure scenarios
+            - Review runbook completeness
+            - Verify incident response procedures
+            - Check alert quality and coverage
+          ready:
+            - SLOs are measurable and validated
+            - Failure scenarios are tested
+            - Incident response process documented
+            - Post-mortem culture established
+            - Disaster recovery approach is tested
+        deploy:
+          focus: |
+            Deploy reliability infrastructure and verify production
+            monitoring. Ensure on-call readiness.
+          activities:
+            - Deploy monitoring and alerting to production
+            - Verify dashboards and alerts work correctly
+            - Confirm on-call rotation is ready
+            - Run production readiness review
+          ready:
+            - Monitoring is live in production
+            - Alerts fire correctly for SLO breaches
+            - On-call team is trained and ready
+            - Production readiness review is complete
+      reference: |
         ## Service Level Concepts
 
         ### SLI (Service Level Indicator)
@@ -305,14 +397,3 @@ skills:
         - **Circuit breakers**: Fail fast when downstream is unhealthy
         - **Bulkheads**: Isolate failures
         - **Graceful degradation**: Partial functionality over total failure
-
-        ## SRE Checklist
-
-        - [ ] SLIs defined for key user journeys
-        - [ ] SLOs set with stakeholder agreement
-        - [ ] Error budget tracking in place
-        - [ ] Alerts are actionable and low-noise
-        - [ ] Runbooks exist for common issues
-        - [ ] Incident response process documented
-        - [ ] Post-mortem culture established
-        - [ ] Resilience patterns implemented