task-complexity-classifier

Files (5)

• CONFIG_TEMPLATE.json
• README.md
• SKILL.md
• classifier.py
• test_classifier.py · tests/

SKILL.md (first lines)

# Task Complexity Classifier

Uses Jev (TypeSafe AI) to figure out how complex a task is, then hands off that judgment to whatever agent you're using. It doesn't pick models or run commands — it just tells you "this is probably complex" and lets you decide what to do with that info.

## What it does (and doesn't do)

**Does:**
- Take a task description and classify it as routine, standard, or complex
- Return the classification with probability scores and a brief explanation
- Fail gracefully if the API is down or you don't have a key set up
- Work with any AI agent — devin, cline, kilo, codex, whatever

**Doesn't:**
- Pick which model to use
- Execute the task
- Call agent-specific tools
- Block your work if something goes wrong

## How it works

1. You give it a task description (text or from a file)
2. It asks Jev to classify the complexity
3. You get back JSON with the classification, probability, confidence, and reasoning
4. If anything breaks, it falls back to "complex" as a safe default

## What you get back

```json
{
  "classification": "standard",
  "probability": 0.87,
  "confidence": 0.92,
  "reasoning": "Task involves multiple components and requires domain knowledge",
  "distribution": {
    "routine": 0.05,
    "standard": 0.87,
    "complex": 0.08
  },
  "fallback_used": false
}
```

The fields:
- `classification`: routine, standard, or complex (you can customize these)
- `probability`: how confident Jev is about this classification
- `confidence`: Jev's internal confidence score
- `reasoning`: why it picked this classification
- `distribution`: the full breakdown across all classes
- `fallback_used`: true if something went wrong and it used the safe default

## Setting it up

### API key

You'll need a TypeSafe API key. Set it as an environment variable:

```bash
export TYPESAFE_API_KEY=your_key_here
```

Or put it in a config file:

```bash
mkdir -p ~/.config/task-complexity-classifier
chmod 700 ~/.config/task-complexity-classifier
touch ~/.config/task-complexity-classifier/.env
chmod 600 ~/.config/task-complexity-classifier/.env
# Then add: TYPESAFE_API_KEY=your_key_here
```

### Complexity classes

By default it uses three classes:
- **routine**: Simple stuff with clear steps
- **standard**: Moderate complexity, needs some domain knowledge
- **complex**: Hard stuff requiring deep reasoning or multiple domains

You can customize these in `config.json` if you want different classes.

### Thresholds

- `min_probability`: 0.8 (if confidence is below this, use the safe default)
- `fallback_class`: "complex" (what to return when uncertain)

## Using it

### From the command line

```bash
# Direct usage
python skills/task-complexity-classifier/classifier.py "Fix a typo in the README"

# From a file
python skills/task-complexity-classifier/classifier.py < task.txt

# With custom config
python skills/task-complexity-classifier/classifier.py --config /path/to/config.json "Add input validation"

# Dry run (no API call)
python skills/task-complexity-classifier/classifier.py --dry-run "Explain how the main function works"
```

### From an agent skill

Your agent's skill system calls this, gets JSON back, and does whatever makes sense for your setup:

```python
classification = json.loads(skill_output)
if classification["classification"] == "complex":
    # Use your heavy-duty model
    use_high_reasoning_model()
elif classification["classification"] == "routine":
    # Quick and dirty is fine here
    use_fast_model()
else:
    # Standard case
    use_standard_model()
```

From igmarin/agnostic-planning-skills, MIT.

More from igmarin/agnostic-planning-skills