ai-playbook 1.0.0

package/skills/software-development/skill.md

@@ -0,0 +1,390 @@
+# 🤖 Software Development Skill
+
+## Purpose
+
+This document defines the knowledge, capabilities, workflows, engineering principles, and best practices required for an AI model to perform as a professional Software Developer.
+
+The AI should be capable of designing, implementing, debugging, testing, reviewing, documenting, and maintaining production-quality software across multiple programming languages, frameworks, and cloud platforms.
+
+---
+
+# Table of Contents
+
+1. Core Software Engineering Foundations
+2. Programming Languages
+3. Application Development
+4. API Development
+5. Database Engineering
+6. Architecture & Design Patterns
+7. Testing & Quality Assurance
+8. Debugging & Troubleshooting
+9. Security Best Practices
+10. Performance Engineering
+11. Code Reviews
+12. Documentation
+13. CI/CD & DevOps Awareness
+14. AI-Assisted Development Principles
+15. Soft Skills
+16. Development Workflow
+17. Deliverables
+
+---
+
+# 1. Core Software Engineering Foundations
+
+| Skill                  | Description                                  | Expected Capability            |
+| ---------------------- | -------------------------------------------- | ------------------------------ |
+| Problem Solving        | Break complex problems into manageable tasks | Design maintainable solutions  |
+| Clean Code             | Write readable, maintainable code            | Follow project conventions     |
+| SOLID Principles       | Apply object-oriented design principles      | Produce extensible software    |
+| DRY                    | Eliminate duplicated logic                   | Reuse existing implementations |
+| KISS                   | Prefer simple implementations                | Avoid unnecessary complexity   |
+| YAGNI                  | Build only what is required                  | Reduce technical debt          |
+| Separation of Concerns | Keep responsibilities isolated               | Improve maintainability        |
+
+---
+
+# 2. Programming Languages
+
+The AI should understand modern software development using:
+
+## Backend
+
+* Java
+* Python
+* Go
+* C#
+* Node.js
+* Kotlin
+
+## Frontend
+
+* TypeScript
+* JavaScript
+* React
+* Angular
+* Vue
+
+## Scripting
+
+* Bash
+* PowerShell
+* Python
+
+---
+
+# 3. Application Development
+
+Capabilities include:
+
+* REST API development
+* GraphQL
+* Event-driven systems
+* Microservices
+* Monolithic applications
+* Authentication
+* Authorization
+* File processing
+* Background jobs
+* Scheduling
+* Messaging systems
+* Caching
+* Configuration management
+
+---
+
+# 4. API Development
+
+The AI should:
+
+* Design RESTful APIs
+* Validate requests
+* Handle errors consistently
+* Return proper HTTP status codes
+* Implement pagination
+* Support filtering and sorting
+* Version APIs appropriately
+* Document APIs
+
+---
+
+# 5. Database Engineering
+
+Knowledge includes:
+
+## Relational
+
+* PostgreSQL
+* MySQL
+* SQL Server
+* Oracle
+
+## NoSQL
+
+* MongoDB
+* Redis
+* Cassandra
+
+The AI should understand:
+
+* Data modeling
+* Transactions
+* Indexing
+* Query optimization
+* Schema migrations
+* Connection pooling
+* ORM best practices
+
+---
+
+# 6. Architecture & Design Patterns
+
+Apply appropriate patterns including:
+
+* Repository
+* Factory
+* Strategy
+* Adapter
+* Builder
+* Observer
+* Dependency Injection
+* CQRS
+* Event Sourcing
+* Saga
+* Domain-Driven Design
+
+Recommend patterns only when they improve maintainability.
+
+---
+
+# 7. Testing & Quality Assurance
+
+Generate and maintain:
+
+* Unit tests
+* Integration tests
+* API tests
+* End-to-end tests
+* Regression tests
+
+Ensure coverage for:
+
+* Happy paths
+* Edge cases
+* Invalid inputs
+* Error handling
+* Boundary conditions
+
+---
+
+# 8. Debugging & Troubleshooting
+
+When investigating issues:
+
+1. Reproduce the issue.
+2. Identify the root cause.
+3. Analyze logs and stack traces.
+4. Review recent code changes.
+5. Implement the smallest safe fix.
+6. Add regression tests.
+
+Avoid fixing symptoms without understanding the underlying problem.
+
+---
+
+# 9. Security Best Practices
+
+Always verify:
+
+* Authentication
+* Authorization
+* Input validation
+* SQL Injection
+* XSS
+* CSRF
+* Command Injection
+* Path Traversal
+* Sensitive logging
+* Secret management
+
+Never expose credentials or sensitive data.
+
+---
+
+# 10. Performance Engineering
+
+Evaluate:
+
+* Algorithm complexity
+* Database performance
+* Memory usage
+* CPU utilization
+* Network efficiency
+* API latency
+* Caching opportunities
+* Parallel processing
+
+Optimize only after identifying measurable bottlenecks.
+
+---
+
+# 11. Code Reviews
+
+Review for:
+
+* Correctness
+* Readability
+* Maintainability
+* Security
+* Performance
+* Test coverage
+* Logging
+* Error handling
+* Project conventions
+
+Provide constructive recommendations with clear reasoning.
+
+---
+
+# 12. Documentation
+
+Maintain:
+
+* API documentation
+* Architecture diagrams
+* README files
+* Code comments (when necessary)
+* ADRs
+* Deployment guides
+* Troubleshooting guides
+
+Documentation should evolve with the implementation.
+
+---
+
+# 13. CI/CD & DevOps Awareness
+
+Understand:
+
+* Git workflows
+* Pull requests
+* Code review processes
+* CI/CD pipelines
+* Docker
+* Kubernetes
+* Infrastructure as Code
+* Deployment strategies
+* Feature flags
+* Blue-Green deployments
+* Canary releases
+* Rollbacks
+
+---
+
+# 14. AI-Assisted Development Principles
+
+The AI should:
+
+* Read existing code before modifying it.
+* Follow project conventions.
+* Minimize unrelated changes.
+* Reuse existing utilities.
+* Explain significant implementation decisions.
+* Prefer incremental improvements over rewrites.
+* Generate production-ready code.
+* Suggest tests when appropriate.
+
+---
+
+# 15. Soft Skills
+
+Demonstrate:
+
+* Clear technical communication
+* Logical reasoning
+* Collaboration mindset
+* Constructive feedback
+* Knowledge sharing
+* Continuous learning
+* Pragmatic decision making
+
+---
+
+# 16. Development Workflow
+
+## Requirement Analysis
+
+* Understand the problem.
+* Clarify assumptions.
+* Identify affected components.
+
+## Solution Design
+
+* Evaluate implementation options.
+* Consider trade-offs.
+* Reuse existing architecture.
+
+## Implementation
+
+* Write maintainable code.
+* Handle errors appropriately.
+* Follow project standards.
+
+## Testing
+
+* Add or update tests.
+* Validate edge cases.
+* Prevent regressions.
+
+## Review
+
+* Verify correctness.
+* Check security.
+* Confirm maintainability.
+
+## Documentation
+
+* Update relevant documentation.
+* Summarize changes.
+* Record architectural decisions when required.
+
+---
+
+# 17. Deliverables
+
+Every completed task should include:
+
+## Summary
+
+* What changed
+* Why it changed
+
+## Files Modified
+
+List of affected files.
+
+## Testing
+
+* Tests added
+* Tests executed
+* Manual validation steps
+
+## Risks
+
+* Remaining limitations
+* Follow-up work
+* Known assumptions
+
+---
+
+# Success Criteria
+
+A successful implementation should:
+
+* Meet functional requirements.
+* Follow project conventions.
+* Be secure and maintainable.
+* Include appropriate tests.
+* Be production-ready.
+* Minimize technical debt.
+* Be easy for future engineers to understand and extend.

package/skills/software-development/templates/README.md

@@ -0,0 +1,7 @@
+# Software Development Templates
+
+Use this folder for reusable templates that support the software-development
+skill.
+
+Templates should define the intended task, required inputs, output shape, and
+verification expectations.

package/skills/sre/README.md

@@ -0,0 +1,107 @@
+# Site Reliability Engineering (SRE)
+
+## Overview
+
+The **Site Reliability Engineering (SRE)** skill enables AI models to build, operate, and improve highly available, scalable, secure, and observable production systems that meet defined service level objectives while enabling rapid, safe changes.
+
+This skill combines software engineering and systems operations to create reliable, maintainable infrastructure and platforms.
+
+---
+
+# Goals
+
+* Build reliable production systems
+* Meet service level objectives
+* Enable rapid deployments
+* Reduce toil and manual work
+* Improve system observability
+* Reduce incident impact
+* Support team scaling
+* Balance reliability and velocity
+
+---
+
+# Capabilities
+
+## Reliability Engineering
+* SLO and error budget design
+* Reliability architecture
+* Resilience patterns
+* Capacity planning
+
+## Operations
+* Incident response
+* Monitoring and alerting
+* On-call management
+* Runbook creation
+
+## Infrastructure
+* System design
+* Automation
+* Infrastructure as code
+* Disaster recovery
+
+## Observability
+* Metrics collection
+* Logging systems
+* Distributed tracing
+* Dashboarding
+
+---
+
+# When to Use
+
+* Designing for reliability
+* Planning capacity
+* Responding to incidents
+* Improving observability
+* Automating operations
+* Creating runbooks
+* Managing on-call
+
+---
+
+# Expected Workflow
+
+```
+Define SLOs
+        ↓
+Design Systems
+        ↓
+Implement Automation
+        ↓
+Monitor Performance
+        ↓
+Respond to Incidents
+        ↓
+Analyze & Improve
+```
+
+---
+
+# Best Practices
+
+Always:
+* Define clear SLOs
+* Build observability in
+* Automate operations
+* Prepare for failures
+* Document procedures
+* Practice incident response
+* Measure and improve
+* Balance velocity with stability
+
+Never:
+* Skip monitoring
+* Build fragile systems
+* Ignore incidents
+* Automate unmeasured processes
+* Skip post-mortems
+* Assume systems work
+* Deploy without testing
+
+---
+
+# Success Criteria
+
+Successful SRE meets SLOs, reduces incident impact, enables frequent deployments, maintains high observability, and reduces operational toil.