@forwardimpact/pathway 0.1.0

package/examples/agents/.claude/skills/architecture-design/SKILL.md

@@ -0,0 +1,88 @@
+---
+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.
+---
+
+# 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

package/examples/agents/.claude/skills/cloud-platforms/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: cloud-platforms
+description: |
+  Guide for working with cloud infrastructure and services. Use when
+  deploying to cloud, selecting cloud services, configuring infrastructure,
+  or solving cloud-specific challenges.
+---
+
+# Cloud Platforms
+
+## When to use this skill
+
+Use this skill when:
+
+- Deploying applications to cloud environments
+- Selecting appropriate cloud services
+- Configuring cloud infrastructure
+- Optimizing cloud costs and performance
+- Implementing cloud security best practices
+
+## Service Categories
+
+### Compute
+
+- **VMs/EC2**: Full control, any workload
+- **Containers/ECS/GKE**: Portable, scalable applications
+- **Serverless/Lambda**: Event-driven, pay-per-use
+- **Kubernetes**: Container orchestration at scale
+
+### Storage
+
+- **Object Storage (S3/GCS)**: Unstructured data, backups, static assets
+- **Block Storage (EBS)**: VM disks, databases
+- **File Storage (EFS)**: Shared file systems
+- **Archive (Glacier)**: Long-term, infrequent access
+
+### Databases
+
+- **Managed SQL (RDS/Cloud SQL)**: Relational, ACID transactions
+- **NoSQL (DynamoDB/Firestore)**: Flexible schema, high scale
+- **Cache (ElastiCache/Memorystore)**: Low-latency data access
+- **Data Warehouse (Redshift/BigQuery)**: Analytics at scale
+
+### Messaging
+
+- **Queues (SQS/Cloud Tasks)**: Decoupled processing
+- **Pub/Sub (SNS/Cloud Pub/Sub)**: Event distribution
+- **Streaming (Kinesis/Dataflow)**: Real-time data processing
+
+## Cloud-Native Design
+
+### Principles
+
+- Design for failure (everything fails eventually)
+- Use managed services when possible
+- Automate everything (infrastructure as code)
+- Monitor and alert on all services
+
+### High Availability
+
+- Deploy across multiple availability zones
+- Use load balancers for traffic distribution
+- Implement health checks and auto-healing
+- Design for graceful degradation
+
+### Security
+
+- Principle of least privilege for IAM
+- Encrypt data at rest and in transit
+- Use security groups and network policies
+- Rotate credentials regularly
+
+## Cost Optimization
+
+- Right-size instances based on actual usage
+- Use reserved instances for predictable workloads
+- Leverage spot/preemptible instances for fault-tolerant work
+- Set up billing alerts and budgets
+- Delete unused resources
+
+## Cloud Checklist
+
+- [ ] Service selection matches requirements
+- [ ] Multi-AZ deployment for availability
+- [ ] Security groups properly configured
+- [ ] IAM follows least privilege
+- [ ] Data encrypted at rest and in transit
+- [ ] Monitoring and alerting in place
+- [ ] Cost controls established
+- [ ] Infrastructure defined as code

package/examples/agents/.claude/skills/code-quality-review/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: code-quality-review
+description: |
+  Guide for reviewing code quality, identifying issues, and suggesting
+  improvements. Use when asked to review code, check for best practices,
+  or conduct code reviews.
+---
+
+# Code Quality & Review
+
+## When to use this skill
+
+Use this skill when:
+
+- Reviewing code for quality issues
+- Checking code against best practices
+- Conducting or assisting with code reviews
+- Verifying AI-generated code before committing
+
+## Review Process
+
+### 1. Correctness First
+
+Before anything else, verify the code does what it claims:
+
+- Does it implement the intended behavior?
+- Are there logic errors or off-by-one bugs?
+- Does it handle all specified requirements?
+- Are error conditions handled appropriately?
+
+### 2. Test Coverage
+
+Check that changes are properly tested:
+
+- Unit tests for new functionality
+- Edge cases and error conditions
+- Integration tests where appropriate
+- Tests are readable and maintainable
+
+### 3. Maintainability
+
+Evaluate long-term code health:
+
+- Clear naming (variables, functions, classes)
+- Appropriate abstraction levels
+- No unnecessary duplication (DRY)
+- Single responsibility principle applied
+
+### 4. Code Style
+
+Verify consistency with project standards:
+
+- Follows project coding conventions
+- Consistent formatting and indentation
+- Appropriate comments for non-obvious logic
+- Documentation updated if needed
+
+## Quality Checklist
+
+- [ ] Code compiles and passes all tests
+- [ ] Changes are covered by tests
+- [ ] No obvious security vulnerabilities
+- [ ] Error handling is appropriate
+- [ ] Code follows project conventions
+- [ ] No unnecessary complexity
+- [ ] Documentation updated if needed
+- [ ] No code you don't fully understand

package/examples/agents/.claude/skills/data-modeling/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: data-modeling
+description: |
+  Guide for designing database schemas, data structures, and data
+  architectures. Use when designing tables, optimizing queries, or
+  making decisions about data storage technologies.
+---
+
+# Data Modeling
+
+## When to use this skill
+
+Use this skill when:
+
+- Designing database schemas
+- Optimizing query performance
+- Choosing storage technologies
+- Planning schema migrations
+- Balancing normalization with performance
+
+## Schema Design
+
+### Normalization
+
+- **1NF**: Atomic values, no repeating groups
+- **2NF**: No partial dependencies
+- **3NF**: No transitive dependencies
+- Normalize first, then denormalize strategically
+
+### Denormalization Trade-offs
+
+- Improves read performance
+- Complicates writes and updates
+- Risk of data inconsistency
+- Use for read-heavy workloads
+
+## Data Store Selection
+
+### Relational (SQL)
+
+- Strong consistency requirements
+- Complex queries and joins
+- ACID transactions needed
+- Well-defined schema
+
+### Document (NoSQL)
+
+- Flexible, evolving schemas
+- Hierarchical data
+- Horizontal scaling priority
+- Read-heavy workloads
+
+### Key-Value
+
+- Simple lookup patterns
+- Extreme performance needs
+- Caching layer
+- Session storage
+
+### Time Series
+
+- Temporal data patterns
+- High write throughput
+- Time-based queries
+- Sensor and metrics data
+
+## Indexing Strategy
+
+### When to Index
+
+- Columns in WHERE clauses
+- Join columns
+- ORDER BY columns
+- High-cardinality columns
+
+### Index Trade-offs
+
+- Faster reads, slower writes
+- Storage overhead
+- Maintenance cost
+- Query planner complexity
+
+## Schema Migrations
+
+### Safe Migration Practices
+
+- Make changes backward compatible
+- Add columns before using them
+- Migrate data before dropping columns
+- Test migrations on production-like data
+
+## Data Modeling Checklist
+
+- [ ] Requirements understood
+- [ ] Appropriate storage technology selected
+- [ ] Schema normalized appropriately
+- [ ] Indexes support query patterns
+- [ ] Migration plan is safe
+- [ ] Backward compatibility maintained

package/examples/agents/.claude/skills/developer-experience/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: developer-experience
+description: |
+  Guide for improving developer experience and creating self-service
+  platforms. Use when designing golden paths, creating getting-started
+  guides, reducing developer friction, or building internal platforms.
+---
+
+# Developer Experience
+
+## When to use this skill
+
+Use this skill when:
+
+- Designing developer onboarding experiences
+- Creating golden paths for common workflows
+- Building self-service platform capabilities
+- Reducing friction in developer workflows
+- Writing getting-started documentation
+
+## Golden Path Design
+
+### Principles
+
+- Opinionated but not restrictive
+- Works out of the box with minimal configuration
+- Covers 80% of use cases well
+- Easy to discover, hard to miss
+
+### Components
+
+- **Templates**: Starter projects with best practices
+- **CLI tools**: Automate common tasks
+- **Documentation**: Clear, task-focused guides
+- **Examples**: Working code for common patterns
+
+## Friction Log Process
+
+### Observation
+
+1. Shadow developers doing real tasks
+2. Note every hesitation, confusion, or workaround
+3. Time how long each step takes
+4. Record what documentation they consult
+
+### Analysis
+
+- Categorize friction points (tooling, docs, process)
+- Identify patterns across multiple observations
+- Prioritize by frequency × severity
+- Distinguish symptoms from root causes
+
+### Action
+
+- Quick wins: Fix in days, high impact
+- Medium-term: Requires design, weeks
+- Strategic: Platform changes, months
+
+## Self-Service Design
+
+### Day 1 Experience
+
+- New developer can deploy in < 1 hour
+- No tickets or approvals needed
+- Immediate feedback on success/failure
+- Clear next steps after initial success
+
+### Day 50 Experience
+
+- Common tasks are still easy
+- Edge cases are documented
+- Escape hatches exist for advanced needs
+- Platform grows with team needs
+
+## Documentation Standards
+
+### Getting Started Guides
+
+- Prerequisites clearly listed
+- Copy-paste commands that work
+- Expected output shown
+- Troubleshooting for common issues
+
+### Reference Documentation
+
+- Complete API coverage
+- Examples for every feature
+- Search-friendly structure
+- Kept in sync with code
+
+## DX Checklist
+
+- [ ] New developer can get started without help
+- [ ] Golden path covers common use cases
+- [ ] Friction points are documented and prioritized
+- [ ] Self-service for common operations
+- [ ] Documentation is discoverable and accurate
+- [ ] Feedback mechanisms exist
+- [ ] Metrics track developer productivity

package/examples/agents/.claude/skills/devops-cicd/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: devops-cicd
+description: |
+  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.
+---
+
+# 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
+
+## CI/CD Pipeline Stages
+
+### Build
+
+- Install dependencies
+- Compile/transpile code
+- Generate artifacts
+- Cache dependencies for speed
+
+### Test
+
+- Run unit tests
+- Run integration tests
+- Static analysis and linting
+- Security scanning
+
+### Deploy
+
+- Deploy to staging environment
+- Run smoke tests
+- Deploy to production
+- Verify deployment health
+
+## Infrastructure as Code
+
+### Terraform
+
+```hcl
+# Define resources declaratively
+resource "aws_instance" "example" {
+  ami           = "ami-0c55b159cbfafe1f0"
+  instance_type = "t2.micro"
+}
+```
+
+### Docker
+
+```dockerfile
+FROM node:18-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY . .
+CMD ["node", "server.js"]
+```
+
+## Deployment Strategies
+
+### Rolling Deployment
+
+- Gradual replacement of instances
+- Zero downtime
+- Easy rollback
+
+### Blue-Green Deployment
+
+- Two identical environments
+- Switch traffic atomically
+- Fast rollback
+
+### Canary Deployment
+
+- 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

package/examples/agents/.claude/skills/full-stack-development/SKILL.md

@@ -0,0 +1,90 @@
+---
+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.
+---
+
+# 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