Core Concepts

interface ToolEvent {
  id: string;              // Unique event ID
  sessionId: string;       // Groups events by conversation
  projectPath: string;     // Project being worked on
  toolName: string;        // e.g., "Read", "Edit", "Bash"
  toolInput: Record<string, unknown>;
  toolResponse: string | null;
  success: boolean;        // Did the tool call succeed?
  timestamp: string;       // ISO-8601 timestamp
  agentId?: string;        // Which agent (Claude, Cursor, etc.)
}

interface DetectedPattern {
  id: string;
  toolSequence: string[];           // e.g., ["Read", "Edit", "Bash"]
  occurrenceCount: number;          // How many times seen
  confidence: number;               // 0.0 to 1.0
  sessionIds: string[];             // Which sessions
  firstSeen: string;                // When first detected
  lastSeen: string;                 // Most recent occurrence
  successRate: number;              // Success rate (0.0 to 1.0)
  suggestedName: string;            // Auto-generated name
  suggestedDescription: string;     // Auto-generated description
  
  // Rich context
  sessionContext?: {
    primary_intent: string;         // debug, implement, etc.
    problem_domains: string[];      // ["react", "typescript"]
    workflow_type: string;          // TDD, deployment, etc.
    tool_success_rate: number;
  };
  
  codeContext?: {
    primary_languages: string[];
    analyzed_files: number;
  };
  
  designPatterns?: DesignPattern[];
}

---
name: react-test-workflow
description: Workflow for testing React components with TypeScript
auto-generated: true
source-sessions: ["session-1", "session-2"]
confidence: 0.85
tags: ["react", "typescript", "testing", "TDD"]
workflow-type: TDD
---

# React Test Workflow

This skill codifies a workflow for testing React components using TypeScript.

## When to Use

Use this skill when:
- Writing tests for React components
- Following TDD methodology
- Working with TypeScript and Jest/Vitest

## Steps

1. Read the component file to understand its structure
2. Search for existing test patterns
3. Create or update the test file
4. Run tests and verify results

## Example

```typescript
import { render, screen } from '@testing-library/react';
import { MyComponent } from './MyComponent';

describe('MyComponent', () => {
  it('renders correctly', () => {
    render(<MyComponent />);
    expect(screen.getByText('Hello')).toBeInTheDocument();
  });
});

## Human-in-the-Loop Model

Auto-Skill never automatically activates skills. You maintain full control:

<CardGroup cols={2}>
  <Card title="User Confirmation" icon="hand">
    Skills require explicit approval before activation. Review the generated skill and decide whether to use it.
  </Card>
  
  <Card title="Customization" icon="pen">
    Edit skills before activation. Modify steps, add context, or adjust parameters.
  </Card>
  
  <Card title="Ignore/Blacklist" icon="ban">
    Ignore patterns you don't want. Blacklist patterns that shouldn't be suggested again.
  </Card>
  
  <Card title="Graduation" icon="graduation-cap">
    Decide when to graduate local patterns to community skills. Auto-Skill suggests, you approve.
  </Card>
</CardGroup>

## Confidence Scoring

Auto-Skill uses confidence scores to guide suggestions:

| Confidence | Source | Meaning | Action |
|-----------|--------|---------|--------|
| 50% | External | Newly discovered community skill | Suggest for trial |
| 75% | Proven | Successfully used 5+ times | Recommend adoption |
| 85% | Graduated | Local pattern replaced by community skill | Strongly recommend |
| 95% | Established | High usage, high success rate | Auto-suggest |

<Note>
  Confidence evolves over time based on usage and success rate. A skill that starts at 50% can grow to 95% as it proves effective in your workflow.
</Note>

## Key Design Decisions

Auto-Skill's architecture is based on several important design choices:

### Agent Plugin Architecture

Instead of being a standalone tool, Auto-Skill integrates as a plugin:
- **Hooks** for observation
- **Skills** for output
- **Symlinks** for cross-agent sharing

### Local-First Storage

All data stays on your machine:
- SQLite for event storage
- Filesystem for generated skills
- No cloud dependencies

### Per-Project + Global Detection

Patterns are detected both:
- **Per-project**: Specific to your current codebase
- **Globally**: Across all projects you work on

### Pluggable Providers

Skill sources are extensible:
- **Local**: Your own generated skills
- **Skills.sh**: 27,000+ community skills
- **Well-known**: RFC 8615 `.well-known/ai-skills` endpoints
- **Custom**: Add your own providers

## Multi-Agent Support

Auto-Skill works with multiple AI coding agents:

- Claude Code (claude.ai/code)
- Cursor (cursor.sh)
- GitHub Codex
- Aider (aider.chat)
- Windsurf
- Any agent supporting SKILL.md format

**Cross-agent sharing** is enabled via symlinks. A skill generated for Claude can be used by Cursor, and vice versa.

<Tip>
  Use `auto-skill agents list` to see all known agents. Use `auto-skill agents detect` to find installed agents on your system.
</Tip>

## Next Steps

<CardGroup cols={3}>
  <Card title="API Reference" icon="code" href="/api/pattern-detector">
    Explore all SDK functions
  </Card>
  
  <Card title="CLI Guide" icon="terminal" href="/cli/overview">
    Learn CLI commands
  </Card>
  
  <Card title="Examples" icon="flask" href="https://github.com/MaTriXy/auto-skill/tree/main/examples">
    View code examples
  </Card>
</CardGroup>