@cloudstreamsoftware/claude-tools 1.0.0 → 1.2.0

package/skills/tutorial/tracks/accelerated/day-1-core-concepts.md

@@ -0,0 +1,234 @@
+# Day 1: Core Concepts & Philosophy
+
+**Duration**: 2-3 hours
+**Covers**: Standard Lessons 0-1 (Philosophy, Core Architecture)
+
+---
+
+## Part 1: The CloudStream Philosophy
+
+### Why This System Exists
+
+CloudStream Software LLC is a consultancy serving regulated industries. This means:
+
+- **Billable work** that must be traceable and auditable
+- **Multiple clients** requiring strict isolation
+- **Compliance requirements** (HIPAA, SOC2, PCI-DSS)
+- **Knowledge compounding** across engagements
+
+The CloudStream Claude Tools system enforces a single principle:
+
+> **All work must meet top 1% enterprise professional quality - the Golden Standard.**
+
+This is code that would pass review at Google, Microsoft, or Amazon. Every commit auditable. Every pattern reusable.
+
+### The Golden Standard
+
+What "top 1%" means in practice:
+
+| Aspect | Requirement |
+|--------|-------------|
+| Code Quality | Production-ready, bulletproof |
+| Test Coverage | 80%+ with TDD workflow |
+| Security | OWASP Top 10 awareness, reviewed |
+| Documentation | Handoff-ready, no tribal knowledge |
+| Compliance | Audit-ready for regulated industries |
+
+---
+
+## Part 2: The Daily Workflow Lifecycle
+
+### Session Start (Automatic)
+
+When Claude Code launches:
+1. Context restored from previous session
+2. Client/project detected from credentials
+3. Tutorial progress shown if incomplete
+4. Learned patterns loaded from knowledge base
+
+**Key insight**: You never start from zero. The system remembers.
+
+### The Core Loop
+
+Every feature follows four steps:
+
+```
+/plan  →  /tdd  →  /code-review  →  /verify
+```
+
+| Step | Command | Why |
+|------|---------|-----|
+| 1 | `/plan` | Prevents scope creep, aligns on approach |
+| 2 | `/tdd` | Tests first ensure testability |
+| 3 | `/code-review` | Catches issues before PR |
+| 4 | `/verify` | Final validation before commit |
+
+This sequence prevents the most common development failures.
+
+### Session End (Automatic)
+
+When your session ends:
+1. State saved automatically
+2. Run `/learn` to extract reusable patterns
+3. Patterns available for future projects
+
+---
+
+## Part 3: The Architecture
+
+### Commands → Agents → Rules → Skills
+
+The system uses a layered architecture:
+
+```
+┌─────────────────────────────────────┐
+│ COMMANDS (/verify, /plan, /tdd)     │ ← What you type
+├─────────────────────────────────────┤
+│ AGENTS (planner, tdd-guide, etc)    │ ← Specialized AI personas
+├─────────────────────────────────────┤
+│ RULES (CLAUDE.md, frontmatter)      │ ← Behavior constraints
+├─────────────────────────────────────┤
+│ SKILLS (zoho-patterns, tdd, etc)    │ ← Reusable knowledge
+└─────────────────────────────────────┘
+```
+
+**Think of it like a restaurant**:
+- Commands = your order ("I'll have the steak")
+- Agents = the chef (knows techniques)
+- Rules = the recipe (constraints)
+- Skills = cooking techniques
+
+### Why This Matters
+
+1. **Consistency**: Same command, same workflow every time
+2. **Expertise**: Agents have deep domain knowledge
+3. **Customization**: Rules adjust per-project
+4. **Extensibility**: Add skills without breaking others
+
+You don't need to memorize all agents or rules. Learn the commands; the system handles the rest.
+
+---
+
+## Part 4: Training Mode
+
+The key differentiator from vanilla Claude Code:
+
+| Vanilla Claude | CloudStream Claude Tools |
+|----------------|------------------------|
+| Reactive | Proactive guidance |
+| No workflow suggestions | Optimal patterns suggested |
+| Fresh start each session | Context persists |
+| You must know best practices | Best practices built-in |
+
+### How Training Mode Works
+
+When you type a request, the system:
+1. **Analyzes intent** via keyword detection
+2. **Suggests optimal command sequence**
+3. **Explains why** this order matters
+4. **Lets you proceed, modify, or skip**
+
+Example:
+```
+You: "Add a login feature"
+
+[Training Mode] Intent: NEW FEATURE + SECURITY-SENSITIVE
+
+Suggested workflow:
+  /plan "Add login feature"
+  /tdd "Login component"
+  /code-review (with security focus)
+  /verify
+
+Rationale: Plan prevents scope creep. TDD ensures testability.
+Security review catches auth vulnerabilities.
+
+Ready to proceed? (yes/modify/skip)
+```
+
+Over time, these patterns become muscle memory.
+
+---
+
+## Exercises
+
+### Exercise 1.1: First Session Observation
+
+Start a new Claude Code session and observe:
+- What context is restored?
+- What client/project is detected?
+- What recommendations appear?
+
+### Exercise 1.2: Run Your First Command
+
+Navigate to a project directory and run:
+```
+/verify
+```
+
+Observe:
+1. Build check runs
+2. Tests execute
+3. Lint validates code style
+4. Type check verifies TypeScript
+
+Note: If `/verify` finds issues, that's fine. The goal is seeing the workflow.
+
+### Exercise 1.3: Understand the Architecture
+
+Run:
+```
+/audit
+```
+
+This shows:
+- Memory MCP status
+- Feature availability
+- System configuration
+- Active compliance mode
+
+### Exercise 1.4: Training Mode in Action
+
+Type a natural request:
+```
+Add validation to the user form
+```
+
+Observe:
+- Does it suggest a workflow?
+- What's the rationale?
+- Can you modify or skip?
+
+---
+
+## Verification Checklist
+
+Before proceeding to Day 2, confirm:
+
+- [ ] Understand the Golden Standard quality bar
+- [ ] Can explain the core loop: plan → tdd → code-review → verify
+- [ ] Ran `/verify` and saw multi-step output
+- [ ] Ran `/audit` and saw system health status
+- [ ] Understand how Training Mode suggests workflows
+
+---
+
+## Key Takeaways
+
+1. **The system makes the right way the easy way** - quality is built-in, not bolted on
+2. **Knowledge compounds** - work on Client A accelerates Client B
+3. **Four commands form the core loop** - plan/tdd/code-review/verify
+4. **Training Mode teaches while you work** - suggestions become muscle memory
+
+---
+
+## Quick Reference
+
+```
+/verify     - Validate project state
+/audit      - System health check
+```
+
+---
+
+**Day 1 Complete** | Next: [Day 2 - Essential Commands](day-2-essential-commands.md)

package/skills/tutorial/tracks/accelerated/day-2-essential-commands.md

@@ -0,0 +1,270 @@
+# Day 2: Essential Commands & Training Mode
+
+**Duration**: 2-3 hours
+**Covers**: Standard Lessons 2-3 (Training Mode, Essential Commands)
+
+---
+
+## Part 1: Training Mode Deep Dive
+
+### Intent Detection
+
+The system analyzes your requests using keyword patterns:
+
+| Intent | Keywords | Suggested Workflow |
+|--------|----------|-------------------|
+| New Feature | "add", "create", "implement" | plan → tdd → code-review → verify |
+| Bug Fix | "fix", "bug", "broken", "error" | tdd (reproduce) → fix → verify |
+| Refactor | "refactor", "improve", "clean" | checkpoint → refactor → code-review → verify |
+| Documentation | "document", "explain", "docs" | plan → write → review |
+
+### Workflow Suggestions
+
+When Training Mode detects intent, it provides:
+
+```
+[Training Mode] Intent detected: NEW FEATURE
+
+Suggested workflow:
+  1. /plan "feature description"     # Design first
+  2. /tdd "component name"           # Tests before code
+  3. /code-review                    # Quality check
+  4. /verify                         # Final validation
+
+Rationale: [Explanation of why this order matters]
+
+Ready to proceed? (yes/modify/skip)
+```
+
+### Customizing Responses
+
+You can:
+- **yes**: Execute the suggested workflow
+- **modify**: Adjust the sequence
+- **skip**: Proceed without guidance (not recommended)
+
+---
+
+## Part 2: The Essential Commands
+
+### The Core Six
+
+These 6 commands cover 90% of daily work:
+
+| # | Command | Purpose | When to Use |
+|---|---------|---------|-------------|
+| 1 | `/audit` | System health | Start of session, debugging |
+| 2 | `/verify` | Validate project | Before every commit |
+| 3 | `/plan` | Design implementation | Complex features (>30 min) |
+| 4 | `/tdd` | Test-driven development | All new code |
+| 5 | `/code-review` | Quality check | Before PR |
+| 6 | `/checkpoint` | Recovery point | Before risky changes |
+
+### The Safety Workflow
+
+```
+/audit → /checkpoint → /plan → /tdd → /code-review → /verify → commit
+```
+
+Each command prevents specific problems:
+
+| Command | Prevents |
+|---------|----------|
+| `/audit` | Working with broken system config |
+| `/checkpoint` | Losing work during risky changes |
+| `/plan` | Scope creep and requirement churn |
+| `/tdd` | Untestable code, low coverage |
+| `/code-review` | Security holes, code smells |
+| `/verify` | Broken builds reaching CI |
+
+---
+
+## Part 3: Command Details
+
+### /audit - System Health Check
+
+```
+/audit
+```
+
+Shows:
+- Memory MCP connection status
+- Feature availability (hooks, skills, agents)
+- Active compliance mode
+- Configuration issues
+
+**Use when**: Start of session, debugging strange behavior
+
+### /verify - Project Validation
+
+```
+/verify
+```
+
+Runs:
+1. Build check
+2. Test suite
+3. Linting
+4. Type checking
+
+**Use when**: Before every commit, after significant changes
+
+### /plan - Implementation Design
+
+```
+/plan "add user authentication with OAuth"
+```
+
+Produces:
+- Step-by-step implementation plan
+- Risk assessment
+- File changes overview
+- Estimated complexity
+
+**Use when**: Features taking >30 minutes, architectural decisions
+
+### /tdd - Test-Driven Development
+
+```
+/tdd "UserAuth component"
+```
+
+Follows RED → GREEN → REFACTOR:
+1. Writes failing tests first
+2. Implements minimal code to pass
+3. Refactors while keeping tests green
+
+**Use when**: All new code, enforces 80%+ coverage
+
+### /code-review - Quality Check
+
+```
+/code-review
+/code-review --security  # For auth/payment code
+```
+
+Checks:
+- Code quality and patterns
+- Security vulnerabilities
+- Performance issues
+- Documentation gaps
+
+**Use when**: Before PR, after implementing features
+
+### /checkpoint - Recovery Point
+
+```
+/checkpoint
+/checkpoint "before-refactor"  # Named checkpoint
+```
+
+Creates:
+- Git stash or branch
+- Restoration instructions
+- Safe rollback point
+
+**Use when**: Before refactors, risky changes, experiments
+
+---
+
+## Exercises
+
+### Exercise 2.1: Practice the Safety Workflow
+
+Create a test file and practice the full workflow:
+
+```javascript
+// practice.js
+function greet(name) {
+  return `Hello, ${name}!`;
+}
+```
+
+**Step 1**: Check system health
+```
+/audit
+```
+
+**Step 2**: Create checkpoint
+```
+/checkpoint "before-practice"
+```
+
+**Step 3**: Plan enhancement
+```
+/plan "add greeting customization"
+```
+
+**Step 4**: Implement with TDD
+```
+/tdd "custom greeting"
+```
+
+**Step 5**: Review quality
+```
+/code-review
+```
+
+**Step 6**: Validate
+```
+/verify
+```
+
+### Exercise 2.2: Training Mode Interaction
+
+Type this natural request:
+```
+I need to add form validation to the signup page
+```
+
+Observe:
+1. What workflow is suggested?
+2. What's the rationale?
+3. Choose "modify" and customize the sequence
+
+### Exercise 2.3: Recovery Practice
+
+1. Run `/checkpoint "experiment"`
+2. Make some changes to files
+3. Decide you don't like them
+4. Practice rolling back
+
+---
+
+## Verification Checklist
+
+Before proceeding to Day 3, confirm:
+
+- [ ] Can execute all 6 essential commands
+- [ ] Understand when to use each command
+- [ ] Practiced the safety workflow sequence
+- [ ] Interacted with Training Mode suggestions
+- [ ] Created and used a checkpoint
+
+---
+
+## Key Takeaways
+
+1. **Six commands cover 90% of work** - master these first
+2. **Training Mode learns your patterns** - use it, don't skip it
+3. **Checkpoints before risk** - cheap insurance
+4. **Verify before commit** - catches 80% of issues
+
+---
+
+## Quick Reference
+
+```
+/audit                    - System health check
+/verify                   - Build/test/lint/typecheck
+/plan "description"       - Create implementation plan
+/tdd "component"          - Test-driven development
+/code-review              - Quality check
+/code-review --security   - Security-focused review
+/checkpoint               - Create recovery point
+/checkpoint "name"        - Named checkpoint
+```
+
+---
+
+**Day 2 Complete** | Next: [Day 3 - Workflow Mastery](day-3-workflow-mastery.md)