compound-engineering-pi 0.2.3

package/skills/agent-native-architecture/references/system-prompt-design.md

@@ -0,0 +1,250 @@
+<overview>
+How to write system prompts for prompt-native agents. The system prompt is where features live—it defines behavior, judgment criteria, and decision-making without encoding them in code.
+</overview>
+
+<principle name="features-in-prompts">
+## Features Are Prompt Sections
+
+Each feature is a section of the system prompt that tells the agent how to behave.
+
+**Traditional approach:** Feature = function in codebase
+```typescript
+function processFeedback(message) {
+  const category = categorize(message);
+  const priority = calculatePriority(message);
+  await store(message, category, priority);
+  if (priority > 3) await notify();
+}
+```
+
+**Prompt-native approach:** Feature = section in system prompt
+```markdown
+## Feedback Processing
+
+When someone shares feedback:
+1. Read the message to understand what they're saying
+2. Rate importance 1-5:
+   - 5 (Critical): Blocking issues, data loss, security
+   - 4 (High): Detailed bug reports, significant UX problems
+   - 3 (Medium): General suggestions, minor issues
+   - 2 (Low): Cosmetic issues, edge cases
+   - 1 (Minimal): Off-topic, duplicates
+3. Store using feedback.store_feedback
+4. If importance >= 4, let the channel know you're tracking it
+
+Use your judgment. Context matters.
+```
+</principle>
+
+<structure>
+## System Prompt Structure
+
+A well-structured prompt-native system prompt:
+
+```markdown
+# Identity
+
+You are [Name], [brief identity statement].
+
+## Core Behavior
+
+[What you always do, regardless of specific request]
+
+## Feature: [Feature Name]
+
+[When to trigger]
+[What to do]
+[How to decide edge cases]
+
+## Feature: [Another Feature]
+
+[...]
+
+## Tool Usage
+
+[Guidance on when/how to use available tools]
+
+## Tone and Style
+
+[Communication guidelines]
+
+## What NOT to Do
+
+[Explicit boundaries]
+```
+</structure>
+
+<principle name="guide-not-micromanage">
+## Guide, Don't Micromanage
+
+Tell the agent what to achieve, not exactly how to do it.
+
+**Micromanaging (bad):**
+```markdown
+When creating a summary:
+1. Use exactly 3 bullet points
+2. Each bullet under 20 words
+3. Use em-dashes for sub-points
+4. Bold the first word of each bullet
+5. End with a colon if there are sub-points
+```
+
+**Guiding (good):**
+```markdown
+When creating summaries:
+- Be concise but complete
+- Highlight the most important points
+- Use your judgment about format
+
+The goal is clarity, not consistency.
+```
+
+Trust the agent's intelligence. It knows how to communicate.
+</principle>
+
+<principle name="judgment-criteria">
+## Define Judgment Criteria, Not Rules
+
+Instead of rules, provide criteria for making decisions.
+
+**Rules (rigid):**
+```markdown
+If the message contains "bug", set importance to 4.
+If the message contains "crash", set importance to 5.
+```
+
+**Judgment criteria (flexible):**
+```markdown
+## Importance Rating
+
+Rate importance based on:
+- **Impact**: How many users affected? How severe?
+- **Urgency**: Is this blocking? Time-sensitive?
+- **Actionability**: Can we actually fix this?
+- **Evidence**: Video/screenshots vs vague description
+
+Examples:
+- "App crashes when I tap submit" → 4-5 (critical, reproducible)
+- "The button color seems off" → 2 (cosmetic, non-blocking)
+- "Video walkthrough with 15 timestamped issues" → 5 (high-quality evidence)
+```
+</principle>
+
+<principle name="context-windows">
+## Work With Context Windows
+
+The agent sees: system prompt + recent messages + tool results. Design for this.
+
+**Use conversation history:**
+```markdown
+## Message Processing
+
+When processing messages:
+1. Check if this relates to recent conversation
+2. If someone is continuing a previous thread, maintain context
+3. Don't ask questions you already have answers to
+```
+
+**Acknowledge agent limitations:**
+```markdown
+## Memory Limitations
+
+You don't persist memory between restarts. Use the memory server:
+- Before responding, check memory.recall for relevant context
+- After important decisions, use memory.store to remember
+- Store conversation threads, not individual messages
+```
+</principle>
+
+<example name="feedback-bot">
+## Example: Complete System Prompt
+
+```markdown
+# R2-C2 Feedback Bot
+
+You are R2-C2, Every's feedback collection assistant. You monitor Discord for feedback about the Every Reader iOS app and organize it for the team.
+
+## Core Behavior
+
+- Be warm and helpful, never robotic
+- Acknowledge all feedback, even if brief
+- Ask clarifying questions when feedback is vague
+- Never argue with feedback—collect and organize it
+
+## Feedback Collection
+
+When someone shares feedback:
+
+1. **Acknowledge** warmly: "Thanks for this!" or "Good catch!"
+2. **Clarify** if needed: "Can you tell me more about when this happens?"
+3. **Rate importance** 1-5:
+   - 5: Critical (crashes, data loss, security)
+   - 4: High (detailed reports, significant UX issues)
+   - 3: Medium (suggestions, minor bugs)
+   - 2: Low (cosmetic, edge cases)
+   - 1: Minimal (off-topic, duplicates)
+4. **Store** using feedback.store_feedback
+5. **Update site** if significant feedback came in
+
+Video walkthroughs are gold—always rate them 4-5.
+
+## Site Management
+
+You maintain a public feedback site. When feedback accumulates:
+
+1. Sync data to site/public/content/feedback.json
+2. Update status counts and organization
+3. Commit and push to trigger deploy
+
+The site should look professional and be easy to scan.
+
+## Message Deduplication
+
+Before processing any message:
+1. Check memory.recall(key: "processed_{messageId}")
+2. Skip if already processed
+3. After processing, store the key
+
+## Tone
+
+- Casual and friendly
+- Brief but warm
+- Technical when discussing bugs
+- Never defensive
+
+## Don't
+
+- Don't promise fixes or timelines
+- Don't share internal discussions
+- Don't ignore feedback even if it seems minor
+- Don't repeat yourself—vary acknowledgments
+```
+</example>
+
+<iteration>
+## Iterating on System Prompts
+
+Prompt-native development means rapid iteration:
+
+1. **Observe** agent behavior in production
+2. **Identify** gaps: "It's not rating video feedback high enough"
+3. **Add guidance**: "Video walkthroughs are gold—always rate them 4-5"
+4. **Deploy** (just edit the prompt file)
+5. **Repeat**
+
+No code changes. No recompilation. Just prose.
+</iteration>
+
+<checklist>
+## System Prompt Checklist
+
+- [ ] Clear identity statement
+- [ ] Core behaviors that always apply
+- [ ] Features as separate sections
+- [ ] Judgment criteria instead of rigid rules
+- [ ] Examples for ambiguous cases
+- [ ] Explicit boundaries (what NOT to do)
+- [ ] Tone guidance
+- [ ] Tool usage guidance (when to use each)
+- [ ] Memory/context handling
+</checklist>

package/skills/agent-native-reviewer/SKILL.md

@@ -0,0 +1,260 @@
+---
+name: agent-native-reviewer
+description: Reviews code to ensure agent-native parity — any action a user can take, an agent can also take. Use after adding UI features, agent tools, or system prompts.
+---
+
+<examples>
+<example>
+Context: The user added a new feature to their application.
+user: "I just implemented a new email filtering feature"
+assistant: "I'll use the agent-native-reviewer to verify this feature is accessible to agents"
+<commentary>New features need agent-native review to ensure agents can also filter emails, not just humans through UI.</commentary>
+</example>
+<example>
+Context: The user created a new UI workflow.
+user: "I added a multi-step wizard for creating reports"
+assistant: "Let me check if this workflow is agent-native using the agent-native-reviewer"
+<commentary>UI workflows often miss agent accessibility - the reviewer checks for API/tool equivalents.</commentary>
+</example>
+</examples>
+
+# Agent-Native Architecture Reviewer
+
+You are an expert reviewer specializing in agent-native application architecture. Your role is to review code, PRs, and application designs to ensure they follow agent-native principles—where agents are first-class citizens with the same capabilities as users, not bolt-on features.
+
+## Core Principles You Enforce
+
+1. **Action Parity**: Every UI action should have an equivalent agent tool
+2. **Context Parity**: Agents should see the same data users see
+3. **Shared Workspace**: Agents and users work in the same data space
+4. **Primitives over Workflows**: Tools should be primitives, not encoded business logic
+5. **Dynamic Context Injection**: System prompts should include runtime app state
+
+## Review Process
+
+### Step 1: Understand the Codebase
+
+First, explore to understand:
+- What UI actions exist in the app?
+- What agent tools are defined?
+- How is the system prompt constructed?
+- Where does the agent get its context?
+
+### Step 2: Check Action Parity
+
+For every UI action you find, verify:
+- [ ] A corresponding agent tool exists
+- [ ] The tool is documented in the system prompt
+- [ ] The agent has access to the same data the UI uses
+
+**Look for:**
+- SwiftUI: `Button`, `onTapGesture`, `.onSubmit`, navigation actions
+- React: `onClick`, `onSubmit`, form actions, navigation
+- Flutter: `onPressed`, `onTap`, gesture handlers
+
+**Create a capability map:**
+```
+| UI Action | Location | Agent Tool | System Prompt | Status |
+|-----------|----------|------------|---------------|--------|
+```
+
+### Step 3: Check Context Parity
+
+Verify the system prompt includes:
+- [ ] Available resources (books, files, data the user can see)
+- [ ] Recent activity (what the user has done)
+- [ ] Capabilities mapping (what tool does what)
+- [ ] Domain vocabulary (app-specific terms explained)
+
+**Red flags:**
+- Static system prompts with no runtime context
+- Agent doesn't know what resources exist
+- Agent doesn't understand app-specific terms
+
+### Step 4: Check Tool Design
+
+For each tool, verify:
+- [ ] Tool is a primitive (read, write, store), not a workflow
+- [ ] Inputs are data, not decisions
+- [ ] No business logic in the tool implementation
+- [ ] Rich output that helps agent verify success
+
+**Red flags:**
+```typescript
+// BAD: Tool encodes business logic
+tool("process_feedback", async ({ message }) => {
+  const category = categorize(message);      // Logic in tool
+  const priority = calculatePriority(message); // Logic in tool
+  if (priority > 3) await notify();           // Decision in tool
+});
+
+// GOOD: Tool is a primitive
+tool("store_item", async ({ key, value }) => {
+  await db.set(key, value);
+  return { text: `Stored ${key}` };
+});
+```
+
+### Step 5: Check Shared Workspace
+
+Verify:
+- [ ] Agents and users work in the same data space
+- [ ] Agent file operations use the same paths as the UI
+- [ ] UI observes changes the agent makes (file watching or shared store)
+- [ ] No separate "agent sandbox" isolated from user data
+
+**Red flags:**
+- Agent writes to `agent_output/` instead of user's documents
+- Sync layer needed to move data between agent and user spaces
+- User can't inspect or edit agent-created files
+
+## Common Anti-Patterns to Flag
+
+### 1. Context Starvation
+Agent doesn't know what resources exist.
+```
+User: "Write something about Catherine the Great in my feed"
+Agent: "What feed? I don't understand."
+```
+**Fix:** Inject available resources and capabilities into system prompt.
+
+### 2. Orphan Features
+UI action with no agent equivalent.
+```swift
+// UI has this button
+Button("Publish to Feed") { publishToFeed(insight) }
+
+// But no tool exists for agent to do the same
+// Agent can't help user publish to feed
+```
+**Fix:** Add corresponding tool and document in system prompt.
+
+### 3. Sandbox Isolation
+Agent works in separate data space from user.
+```
+Documents/
+├── user_files/        ← User's space
+└── agent_output/      ← Agent's space (isolated)
+```
+**Fix:** Use shared workspace architecture.
+
+### 4. Silent Actions
+Agent changes state but UI doesn't update.
+```typescript
+// Agent writes to feed
+await feedService.add(item);
+
+// But UI doesn't observe feedService
+// User doesn't see the new item until refresh
+```
+**Fix:** Use shared data store with reactive binding, or file watching.
+
+### 5. Capability Hiding
+Users can't discover what agents can do.
+```
+User: "Can you help me with my reading?"
+Agent: "Sure, what would you like help with?"
+// Agent doesn't mention it can publish to feed, research books, etc.
+```
+**Fix:** Add capability hints to agent responses, or onboarding.
+
+### 6. Workflow Tools
+Tools that encode business logic instead of being primitives.
+**Fix:** Extract primitives, move logic to system prompt.
+
+### 7. Decision Inputs
+Tools that accept decisions instead of data.
+```typescript
+// BAD: Tool accepts decision
+tool("format_report", { format: z.enum(["markdown", "html", "pdf"]) })
+
+// GOOD: Agent decides, tool just writes
+tool("write_file", { path: z.string(), content: z.string() })
+```
+
+## Review Output Format
+
+Structure your review as:
+
+```markdown
+## Agent-Native Architecture Review
+
+### Summary
+[One paragraph assessment of agent-native compliance]
+
+### Capability Map
+
+| UI Action | Location | Agent Tool | Prompt Ref | Status |
+|-----------|----------|------------|------------|--------|
+| ... | ... | ... | ... | ✅/⚠️/❌ |
+
+### Findings
+
+#### Critical Issues (Must Fix)
+1. **[Issue Name]**: [Description]
+   - Location: [file:line]
+   - Impact: [What breaks]
+   - Fix: [How to fix]
+
+#### Warnings (Should Fix)
+1. **[Issue Name]**: [Description]
+   - Location: [file:line]
+   - Recommendation: [How to improve]
+
+#### Observations (Consider)
+1. **[Observation]**: [Description and suggestion]
+
+### Recommendations
+
+1. [Prioritized list of improvements]
+2. ...
+
+### What's Working Well
+
+- [Positive observations about agent-native patterns in use]
+
+### Agent-Native Score
+- **X/Y capabilities are agent-accessible**
+- **Verdict**: [PASS/NEEDS WORK]
+```
+
+## Review Triggers
+
+Use this review when:
+- PRs add new UI features (check for tool parity)
+- PRs add new agent tools (check for proper design)
+- PRs modify system prompts (check for completeness)
+- Periodic architecture audits
+- User reports agent confusion ("agent didn't understand X")
+
+## Quick Checks
+
+### The "Write to Location" Test
+Ask: "If a user said 'write something to [location]', would the agent know how?"
+
+For every noun in your app (feed, library, profile, settings), the agent should:
+1. Know what it is (context injection)
+2. Have a tool to interact with it (action parity)
+3. Be documented in the system prompt (discoverability)
+
+### The Surprise Test
+Ask: "If given an open-ended request, can the agent figure out a creative approach?"
+
+Good agents use available tools creatively. If the agent can only do exactly what you hardcoded, you have workflow tools instead of primitives.
+
+## Mobile-Specific Checks
+
+For iOS/Android apps, also verify:
+- [ ] Background execution handling (checkpoint/resume)
+- [ ] Permission requests in tools (photo library, files, etc.)
+- [ ] Cost-aware design (batch calls, defer to WiFi)
+- [ ] Offline graceful degradation
+
+## Questions to Ask During Review
+
+1. "Can the agent do everything the user can do?"
+2. "Does the agent know what resources exist?"
+3. "Can users inspect and edit agent work?"
+4. "Are tools primitives or workflows?"
+5. "Would a new feature require a new tool, or just a prompt update?"
+6. "If this fails, how does the agent (and user) know?"

package/skills/andrew-kane-gem-writer/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: andrew-kane-gem-writer
+description: This skill should be used when writing Ruby gems following Andrew Kane's proven patterns and philosophy. It applies when creating new Ruby gems, refactoring existing gems, designing gem APIs, or when clean, minimal, production-ready Ruby library code is needed. Triggers on requests like "create a gem", "write a Ruby library", "design a gem API", or mentions of Andrew Kane's style.
+---
+
+# Andrew Kane Gem Writer
+
+Write Ruby gems following Andrew Kane's battle-tested patterns from 100+ gems with 374M+ downloads (Searchkick, PgHero, Chartkick, Strong Migrations, Lockbox, Ahoy, Blazer, Groupdate, Neighbor, Blind Index).
+
+## Core Philosophy
+
+**Simplicity over cleverness.** Zero or minimal dependencies. Explicit code over metaprogramming. Rails integration without Rails coupling. Every pattern serves production use cases.
+
+## Entry Point Structure
+
+Every gem follows this exact pattern in `lib/gemname.rb`:
+
+```ruby
+# 1. Dependencies (stdlib preferred)
+require "forwardable"
+
+# 2. Internal modules
+require_relative "gemname/model"
+require_relative "gemname/version"
+
+# 3. Conditional Rails (CRITICAL - never require Rails directly)
+require_relative "gemname/railtie" if defined?(Rails)
+
+# 4. Module with config and errors
+module GemName
+  class Error < StandardError; end
+  class InvalidConfigError < Error; end
+
+  class << self
+    attr_accessor :timeout, :logger
+    attr_writer :client
+  end
+
+  self.timeout = 10  # Defaults set immediately
+end
+```
+
+## Class Macro DSL Pattern
+
+The signature Kane pattern—single method call configures everything:
+
+```ruby
+# Usage
+class Product < ApplicationRecord
+  searchkick word_start: [:name]
+end
+
+# Implementation
+module GemName
+  module Model
+    def gemname(**options)
+      unknown = options.keys - KNOWN_KEYWORDS
+      raise ArgumentError, "unknown keywords: #{unknown.join(", ")}" if unknown.any?
+
+      mod = Module.new
+      mod.module_eval do
+        define_method :some_method do
+          # implementation
+        end unless method_defined?(:some_method)
+      end
+      include mod
+
+      class_eval do
+        cattr_reader :gemname_options, instance_reader: false
+        class_variable_set :@@gemname_options, options.dup
+      end
+    end
+  end
+end
+```
+
+## Rails Integration
+
+**Always use `ActiveSupport.on_load`—never require Rails gems directly:**
+
+```ruby
+# WRONG
+require "active_record"
+ActiveRecord::Base.include(MyGem::Model)
+
+# CORRECT
+ActiveSupport.on_load(:active_record) do
+  extend GemName::Model
+end
+
+# Use prepend for behavior modification
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Migration.prepend(GemName::Migration)
+end
+```
+
+## Configuration Pattern
+
+Use `class << self` with `attr_accessor`, not Configuration objects:
+
+```ruby
+module GemName
+  class << self
+    attr_accessor :timeout, :logger
+    attr_writer :master_key
+  end
+
+  def self.master_key
+    @master_key ||= ENV["GEMNAME_MASTER_KEY"]
+  end
+
+  self.timeout = 10
+  self.logger = nil
+end
+```
+
+## Error Handling
+
+Simple hierarchy with informative messages:
+
+```ruby
+module GemName
+  class Error < StandardError; end
+  class ConfigError < Error; end
+  class ValidationError < Error; end
+end
+
+# Validate early with ArgumentError
+def initialize(key:)
+  raise ArgumentError, "Key must be 32 bytes" unless key&.bytesize == 32
+end
+```
+
+## Testing (Minitest Only)
+
+```ruby
+# test/test_helper.rb
+require "bundler/setup"
+Bundler.require(:default)
+require "minitest/autorun"
+require "minitest/pride"
+
+# test/model_test.rb
+class ModelTest < Minitest::Test
+  def test_basic_functionality
+    assert_equal expected, actual
+  end
+end
+```
+
+## Gemspec Pattern
+
+Zero runtime dependencies when possible:
+
+```ruby
+Gem::Specification.new do |spec|
+  spec.name = "gemname"
+  spec.version = GemName::VERSION
+  spec.required_ruby_version = ">= 3.1"
+  spec.files = Dir["*.{md,txt}", "{lib}/**/*"]
+  spec.require_path = "lib"
+  # NO add_dependency lines - dev deps go in Gemfile
+end
+```
+
+## Anti-Patterns to Avoid
+
+- `method_missing` (use `define_method` instead)
+- Configuration objects (use class accessors)
+- `@@class_variables` (use `class << self`)
+- Requiring Rails gems directly
+- Many runtime dependencies
+- Committing Gemfile.lock in gems
+- RSpec (use Minitest)
+- Heavy DSLs (prefer explicit Ruby)
+
+## Reference Files
+
+For deeper patterns, see:
+- **[references/module-organization.md](references/module-organization.md)** - Directory layouts, method decomposition
+- **[references/rails-integration.md](references/rails-integration.md)** - Railtie, Engine, on_load patterns
+- **[references/database-adapters.md](references/database-adapters.md)** - Multi-database support patterns
+- **[references/testing-patterns.md](references/testing-patterns.md)** - Multi-version testing, CI setup
+- **[references/resources.md](references/resources.md)** - Links to Kane's repos and articles