@forwardimpact/pathway 0.1.0

package/examples/behaviours/systems_thinking.yaml

@@ -0,0 +1,41 @@
+# Behaviour: Think in Systems
+# See beyond components to understand whole-system behaviour
+
+name: Think in Systems
+human:
+  description:
+    The ability to see beyond individual components to understand how the entire
+    system behaves. Like understanding how reintroducing wolves to Yellowstone
+    transformed not just deer but rivers, engineers recognize that every
+    service, API, and queue is part of a larger whole—isolated changes ripple
+    across the system.
+  maturityDescriptions:
+    emerging:
+      Recognizes that systems have interconnected parts; considers immediate
+      dependencies in code; understands basic cause-and-effect
+    developing:
+      Identifies upstream and downstream impacts; uses observability tools to
+      trace requests across services; understands feedback loops; maps
+      dependencies before making changes
+    practicing:
+      Maps complex system interactions across technical and business domains;
+      anticipates cascading effects; designs systems that degrade gracefully;
+      understands how technology changes impact business operations
+    role_modeling:
+      Shapes systems design practices across their function; conducts chaos
+      engineering experiments; influences cross-team architecture decisions;
+      creates clarity from complexity; bridges technical systems with business
+      processes
+    exemplifying:
+      Defines organizational systems architecture principles; recognized
+      industry authority on complex systems; advises executive leadership on
+      systemic risks and opportunities; publishes thought leadership on systems
+      thinking in technology organizations
+
+agent:
+  title: Consider the whole system
+  workingStyle: |
+    For every change:
+    1. Identify upstream and downstream impacts
+    2. Consider non-functional requirements (performance, security)
+    3. Document assumptions and trade-offs

package/examples/capabilities/_index.yaml

@@ -0,0 +1,8 @@
+# Auto-generated index for browser loading
+# Do not edit manually - regenerate with: npx pathway --generate-index
+files:
+  - business
+  - delivery
+  - people
+  - reliability
+  - scale

package/examples/capabilities/business.yaml

@@ -0,0 +1,251 @@
+name: Business
+emoji: 💼
+displayOrder: 8
+description: |
+  Understanding and driving business value.
+  Includes domain knowledge, stakeholder management, strategic thinking,
+  and translating between technical and business contexts.
+transitionChecklists:
+  plan_to_code:
+    foundational:
+      - Business context is understood
+      - User needs are identified
+    working:
+      - Business requirements are documented
+      - Stakeholder expectations are aligned
+      - Value proposition is clear
+    practitioner:
+      - Business impact is quantified
+      - Strategic alignment is verified
+      - Cross-team business needs are considered
+    expert:
+      - Enterprise business goals are addressed
+      - Strategic technology decisions are aligned
+      - Executive stakeholders are engaged
+  code_to_review:
+    foundational:
+      - Solution addresses the stated business need
+      - User-facing behavior is correct
+      - Business requirements are met
+    working:
+      - Stakeholder feedback is incorporated
+      - Business value is delivered
+      - Success metrics can be measured
+    practitioner:
+      - Cross-team business requirements are met
+      - ROI is demonstrable
+      - Business risks are mitigated
+    expert:
+      - Strategic business outcomes are enabled
+      - Enterprise value is created
+      - Business innovation is demonstrated
+professionalResponsibilities:
+  awareness:
+    Understand the business context for your assigned work and communicate
+    progress clearly when asked
+  foundational:
+    Connect your technical work to business outcomes, engage with stakeholders
+    to clarify requirements
+  working:
+    Translate business needs into technical solutions, manage stakeholder
+    expectations, and articulate technical decisions in business terms
+  practitioner:
+    Drive business outcomes through technical solutions across your area,
+    influence product roadmaps, and partner effectively with business
+    stakeholders
+  expert:
+    Shape technology-driven business strategy, represent technical perspective
+    at executive level, and be recognized as a bridge between engineering and
+    business
+managementResponsibilities:
+  awareness:
+    Understand business context and communicate team progress to stakeholders
+    with guidance
+  foundational:
+    Align team priorities with business objectives, manage stakeholder
+    relationships, and communicate team impact
+  working:
+    Translate business strategy into team objectives, own stakeholder
+    relationships, and ensure team delivers business value
+  practitioner:
+    Partner with business leaders to shape strategy for your area, influence
+    direction across teams, and deliver measurable business impact
+  expert:
+    Shape technology-driven business strategy, represent engineering at
+    executive level, and own strategic business outcomes
+skills:
+  - id: stakeholder_management
+    name: Stakeholder Management
+    isHumanOnly: true
+    human:
+      description:
+        Building relationships with and managing expectations of stakeholders
+        across the organization, from frontline workers to C-level executives
+      levelDescriptions:
+        awareness:
+          You identify key stakeholders for your work and communicate status
+          when asked. You understand that different stakeholders have different
+          needs.
+        foundational:
+          You proactively update stakeholders on progress, handle basic
+          expectation setting, and escalate concerns appropriately. You build
+          rapport with regular collaborators.
+        working:
+          You manage multiple stakeholders with different interests, navigate
+          conflicting priorities diplomatically, and build trust through
+          consistent delivery. You tailor communication to each audience.
+        practitioner:
+          You influence senior stakeholders effectively across your area, manage
+          complex stakeholder landscapes with competing agendas, build trust
+          rapidly with new stakeholders, and shield teams from organizational
+          friction.
+        expert:
+          You shape stakeholder practices across the business unit. You manage
+          executive relationships, represent engineering at the highest levels,
+          and are recognized for exceptional stakeholder partnerships.
+  - id: technical_writing
+    name: Technical Writing
+    human:
+      description:
+        Creating clear, accurate, and useful technical documentation. Good specs
+        enable AI to generate accurate solutions; poor specs lead to poor
+        results.
+      levelDescriptions:
+        awareness:
+          You document your own work following team templates and standards. You
+          keep code comments current and write basic README content.
+        foundational:
+          You write clear READMEs, inline documentation, and technical guides.
+          You update existing docs when making changes and ensure documentation
+          matches implementation.
+        working:
+          You create comprehensive documentation for complex systems. You write
+          precise specifications that enable accurate AI-generated code,
+          establish documentation practices for your projects, and ensure docs
+          are discoverable.
+        practitioner:
+          You define documentation standards across teams in your area, create
+          documentation systems and templates, train engineers on spec-driven
+          development, and ensure documentation quality across projects.
+        expert:
+          You shape documentation culture and standards across the business
+          unit. You innovate on documentation approaches, are recognized for
+          exceptional technical writing clarity, and lead documentation
+          initiatives.
+    agent:
+      name: technical-writing
+      description: >
+        Guide for creating clear technical documentation. Use when writing
+        READMEs,
+
+        API docs, specifications, or any technical content that needs to be
+        clear
+
+        and accurate.
+      body: |
+        # Technical Writing
+
+        ## When to use this skill
+
+        Use this skill when:
+        - Writing README files
+        - Creating API documentation
+        - Writing technical specifications
+        - Documenting code and systems
+        - Creating guides and tutorials
+
+        ## Writing Principles
+
+        ### Clarity First
+        - Use simple, direct language
+        - One idea per sentence
+        - Active voice over passive
+        - Avoid jargon unless defined
+        - Be specific, not vague
+
+        ### Know Your Audience
+        - What do they already know?
+        - What do they need to accomplish?
+        - What's their skill level?
+        - What questions will they have?
+
+        ### Structure for Scanning
+        - Lead with the most important information
+        - Use headings and subheadings
+        - Keep paragraphs short
+        - Use lists for multiple items
+        - Highlight key terms
+
+        ## Document Types
+
+        ### README
+        - What is this project?
+        - How do I get started?
+        - How do I use it?
+        - Where do I get help?
+
+        ### API Documentation
+        - Endpoint description
+        - Parameters and types
+        - Request/response examples
+        - Error codes and handling
+
+        ### Technical Specification
+        - Problem statement
+        - Proposed solution
+        - Alternatives considered
+        - Implementation plan
+
+        ### Tutorial
+        - Clear learning objective
+        - Prerequisites listed
+        - Step-by-step instructions
+        - Expected outcomes shown
+
+        ## README Template
+
+        ```markdown
+        # Project Name
+
+        Brief description of what this project does.
+
+        ## Getting Started
+
+        ### Prerequisites
+        - Required software and versions
+
+        ### Installation
+        Step-by-step installation instructions.
+
+        ### Quick Start
+        Minimal example to get running.
+
+        ## Usage
+        Common use cases with examples.
+
+        ## Contributing
+        How to contribute to the project.
+
+        ## License
+        License information.
+        ```
+
+        ## Code Examples
+
+        Good examples are:
+        - Complete and runnable
+        - Minimal but realistic
+        - Copy-pasteable
+        - Annotated with comments
+        - Tested and verified
+
+        ## Technical Writing Checklist
+
+        - [ ] Purpose is clear in first paragraph
+        - [ ] Audience is identified
+        - [ ] Prerequisites are listed
+        - [ ] Examples are tested and work
+        - [ ] Technical terms are defined
+        - [ ] Structure supports scanning
+        - [ ] No ambiguous pronouns
+        - [ ] Updated when code changes

package/examples/capabilities/delivery.yaml

@@ -0,0 +1,352 @@
+name: Delivery
+emoji: 🚀
+displayOrder: 1
+description: |
+  Building and shipping solutions that solve real problems.
+  Encompasses full-stack development, data integration, problem discovery,
+  and rapid prototyping.
+transitionChecklists:
+  plan_to_code:
+    foundational:
+      - Requirements are understood and documented
+      - Acceptance criteria are defined
+    working:
+      - Technical approach is documented
+      - Dependencies are identified and planned for
+      - Scope is broken into deliverable increments
+    practitioner:
+      - Cross-team dependencies are coordinated
+      - Risks are identified with mitigation strategies
+      - Delivery timeline is realistic and communicated
+    expert:
+      - Strategic alignment is validated with stakeholders
+      - Resource allocation is optimized across teams
+      - Success metrics are defined and measurable
+  code_to_review:
+    foundational:
+      - Feature works end-to-end
+      - Basic tests cover critical paths
+      - Code is self-reviewed before submitting
+    working:
+      - All acceptance criteria are met
+      - Edge cases are handled
+      - Technical debt is explicitly documented
+    practitioner:
+      - Solution addresses cross-team requirements
+      - Integration points are tested
+      - Rollback plan exists
+    expert:
+      - Organizational standards are followed
+      - Pattern can be reused across teams
+      - Documentation enables others to extend
+professionalResponsibilities:
+  awareness:
+    Complete assigned implementation tasks within established patterns with
+    guidance from senior engineers
+  foundational:
+    Deliver small features end-to-end with minimal guidance, understanding how
+    your code fits the broader system
+  working:
+    Own feature delivery from design through deployment, making sound technical
+    trade-offs to ship value on time
+  practitioner:
+    Lead technical delivery of complex projects across multiple teams, unblock
+    others through hands-on contributions, and ensure engineering quality
+  expert:
+    Drive delivery of the most critical technical initiatives, establish
+    engineering delivery practices across the business unit, and be the
+    technical authority on high-stakes projects
+managementResponsibilities:
+  awareness:
+    Track team progress and communicate status to stakeholders with guidance
+  foundational:
+    Coordinate team delivery by managing dependencies, removing blockers, and
+    keeping stakeholders informed
+  working:
+    Own team delivery outcomes—balance scope, staffing, and timeline; make
+    resourcing decisions to meet commitments
+  practitioner:
+    Drive delivery excellence across multiple teams, establish delivery metrics
+    and practices for your area, hold teams accountable, and escalate cross-team
+    risks
+  expert:
+    Shape delivery culture across the business unit, lead strategic delivery
+    transformations, and represent delivery commitments at executive level
+skills:
+  - id: architecture_design
+    name: Architecture & Design
+    human:
+      description:
+        Ability to design software systems that are scalable, maintainable, and
+        fit for purpose. In the AI era, this includes designing systems that
+        effectively leverage AI capabilities while maintaining human oversight.
+      levelDescriptions:
+        awareness:
+          You understand basic architectural concepts (separation of concerns,
+          modularity, coupling) and can read architecture diagrams. You follow
+          established patterns with guidance.
+        foundational:
+          You explain and apply common patterns (MVC, microservices,
+          event-driven) to familiar problems. You contribute to design
+          discussions and identify when existing patterns don't fit.
+        working:
+          You design components and services independently for moderate
+          complexity. You make appropriate trade-off decisions, document design
+          rationale, and consider AI integration points in your designs.
+        practitioner:
+          You design complex multi-component systems end-to-end, evaluate
+          architectural options for large initiatives across teams, guide
+          technical decisions for your area, and mentor engineers on
+          architecture. You balance elegance with delivery needs.
+        expert:
+          You define architecture standards and patterns across the business
+          unit. You innovate on approaches to large-scale challenges, shape
+          AI-integrated system design, and are recognized externally as an
+          architecture authority.
+    agent:
+      name: architecture-design
+      description: |
+        Guide for designing software systems and making architectural decisions.
+        Use when asked to design a system, evaluate architecture options, or
+        make structural decisions about code organization.
+      body: >
+        # Architecture & Design
+
+
+        ## When to use this skill
+
+
+        Use this skill when:
+
+        - Designing new systems or major features
+
+        - Evaluating architectural options and trade-offs
+
+        - Making decisions about code organization and structure
+
+        - Reviewing or improving existing architecture
+
+
+        ## Design Process
+
+
+        ### 1. Understand Requirements
+
+
+        Before designing, clarify:
+
+        - What problem are we solving?
+
+        - What are the non-functional requirements (scale, latency,
+        availability)?
+
+        - What are the constraints (existing systems, team skills, timeline)?
+
+        - What will change over time?
+
+
+        ### 2. Identify Key Decisions
+
+
+        Architecture is the set of decisions that are hard to change:
+
+        - Data storage and schema design
+
+        - Service boundaries and communication patterns
+
+        - Synchronous vs asynchronous processing
+
+        - Stateful vs stateless components
+
+
+        ### 3. Evaluate Trade-offs
+
+
+        Every architectural choice has trade-offs:
+
+        - Consistency vs availability
+
+        - Simplicity vs flexibility
+
+        - Performance vs maintainability
+
+        - Build vs buy
+
+
+        Document trade-offs explicitly.
+
+
+        ### 4. Design for Change
+
+
+        Good architecture accommodates change:
+
+        - Separate what changes from what stays the same
+
+        - Define clear interfaces between components
+
+        - Prefer composition over inheritance
+
+        - Make dependencies explicit
+
+
+        ## Common Patterns
+
+
+        ### Service Architecture
+
+        - Microservices: Independent deployment, clear boundaries
+
+        - Monolith: Simpler deployment, easier refactoring
+
+        - Modular monolith: Boundaries within single deployment
+
+
+        ### Data Patterns
+
+        - Event sourcing: Full audit trail, complex queries
+
+        - CQRS: Separate read and write models
+
+        - Repository pattern: Abstract data access
+
+
+        ### Communication Patterns
+
+        - REST: Synchronous, request-response
+
+        - Event-driven: Asynchronous, loose coupling
+
+        - gRPC: Efficient, strongly typed
+
+
+        ## Architecture Checklist
+
+
+        - [ ] Requirements are clearly understood
+
+        - [ ] Key decisions are documented with rationale
+
+        - [ ] Trade-offs are explicit
+
+        - [ ] Failure modes are considered
+
+        - [ ] Scalability requirements are addressed
+
+        - [ ] Security implications are reviewed
+
+        - [ ] Dependencies are minimal and explicit
+  - id: full_stack_development
+    name: Full-Stack Development
+    human:
+      description:
+        Building complete solutions across frontend, APIs, databases, and
+        infrastructure without dependencies on specialists. JavaScript and
+        Python are our primary languages, with CloudFormation and Terraform for
+        infrastructure. Essential for rapid delivery and embedded engineering
+        work.
+      levelDescriptions:
+        awareness:
+          You understand how frontend, backend, and database layers work
+          together. You can make changes in one layer with guidance and
+          understand the impact on other layers.
+        foundational:
+          You build simple features across frontend and backend using JavaScript
+          or Python. You understand how layers connect through APIs and can
+          debug across the stack.
+        working:
+          You deliver complete features end-to-end independently—frontend,
+          backend, database, and infrastructure (CloudFormation/Terraform). You
+          make pragmatic technology choices and deploy what you build.
+        practitioner:
+          You build complete applications rapidly across any technology stack
+          for teams in your area. You select the right tools for each problem,
+          balance technical debt with delivery speed, and mentor engineers on
+          full-stack development.
+        expert:
+          You work comfortably in any language and rapidly acquire new skills as
+          needed. You deliver production solutions in days not months, shape
+          full-stack practices across the business unit, and exemplify
+          polymathic engineering.
+    agent:
+      name: full-stack-development
+      description: >
+        Guide for building complete solutions across the full technology stack.
+
+        Use when asked to implement features spanning frontend, backend,
+        database,
+
+        and infrastructure layers.
+      body: |
+        # Full-Stack Development
+
+        ## When to use this skill
+
+        Use this skill when:
+        - Building features that span multiple layers
+        - Implementing end-to-end functionality
+        - Working across frontend, backend, and infrastructure
+        - Debugging issues that cross layer boundaries
+
+        ## Technology Stack
+
+        ### Primary Languages
+        - **JavaScript/TypeScript**: Frontend and Node.js backend
+        - **Python**: Backend APIs and data processing
+
+        ### Infrastructure
+        - **Terraform**: Cloud infrastructure as code
+        - **CloudFormation**: AWS-specific infrastructure
+        - **Docker**: Containerization
+
+        ## Layer Responsibilities
+
+        ### Frontend
+        - User interface and experience
+        - Client-side validation
+        - API integration
+        - State management
+
+        ### Backend API
+        - Business logic
+        - Data validation
+        - Authentication/authorization
+        - External service integration
+
+        ### Database
+        - Data persistence
+        - Query optimization
+        - Schema migrations
+        - Data integrity
+
+        ### Infrastructure
+        - Deployment pipelines
+        - Environment configuration
+        - Scaling and reliability
+        - Monitoring and logging
+
+        ## Development Process
+
+        ### 1. Start with the Interface
+        - Define the API contract first
+        - Frontend and backend can work in parallel
+        - Clear interface = fewer integration issues
+
+        ### 2. Build Vertically
+        - Complete one feature end-to-end before starting another
+        - Validates assumptions early
+        - Delivers demonstrable progress
+
+        ### 3. Test Across Layers
+        - Unit tests per layer
+        - Integration tests across layers
+        - End-to-end tests for critical paths
+
+        ## Full-Stack Checklist
+
+        - [ ] API contract is defined
+        - [ ] Frontend connects to backend correctly
+        - [ ] Database schema supports the feature
+        - [ ] Error handling spans all layers
+        - [ ] Feature works end-to-end
+        - [ ] Deployment is automated