playbooks

home / skills / a5c-ai / babysitter / solution-explainer

solution-explainer skill

/plugins/babysitter/skills/babysit/process/specializations/algorithms-optimization/skills/solution-explainer

This skill provides clear, interview-ready explanations of algorithm solutions, including step-by-step reasoning, complexity, and common pitfalls.

npx playbooks add skill a5c-ai/babysitter --skill solution-explainer

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
1.8 KB
---
name: solution-explainer
description: Generate clear explanations of algorithm solutions
allowed-tools:
  - Read
  - Write
  - Grep
  - Glob
---

# Solution Explainer Skill

## Purpose

Generate clear, educational explanations of algorithm solutions suitable for interviews, learning, and documentation.

## Capabilities

- Step-by-step solution walkthrough
- Time/space complexity explanation
- Alternative approach comparison
- Common mistake highlights
- Visual aids generation
- Interview-style explanation formatting

## Target Processes

- interview-problem-explanation
- leetcode-problem-solving
- mock-coding-interview
- algorithm-implementation

## Explanation Framework

1. **Problem Understanding**: Restate the problem clearly
2. **Approach Overview**: High-level strategy
3. **Algorithm Details**: Step-by-step breakdown
4. **Complexity Analysis**: Time and space with justification
5. **Code Walkthrough**: Annotated implementation
6. **Edge Cases**: Special scenarios handled
7. **Alternatives**: Other valid approaches

## Input Schema

```json
{
  "type": "object",
  "properties": {
    "problem": { "type": "string" },
    "solution": { "type": "string" },
    "language": { "type": "string" },
    "depth": {
      "type": "string",
      "enum": ["brief", "standard", "detailed"]
    },
    "includeVisuals": { "type": "boolean", "default": false },
    "interviewStyle": { "type": "boolean", "default": false }
  },
  "required": ["problem", "solution"]
}
```

## Output Schema

```json
{
  "type": "object",
  "properties": {
    "success": { "type": "boolean" },
    "explanation": { "type": "string" },
    "complexity": { "type": "object" },
    "commonMistakes": { "type": "array" },
    "alternatives": { "type": "array" },
    "visuals": { "type": "array" }
  },
  "required": ["success", "explanation"]
}
```

Overview

This skill generates clear, educational explanations of algorithm solutions for interviews, learning, and documentation. It transforms a given problem and solution into a structured walkthrough that highlights intent, steps, complexity, and alternatives. Outputs are adaptable by depth and can be formatted for interview-style delivery or documentation use.

How this skill works

Provide the problem statement and the solution code or approach; the skill restates the problem, outlines a high-level strategy, and breaks the algorithm into a step-by-step explanation. It annotates key operations, derives time and space complexity, surfaces common pitfalls, and compares alternative approaches. Optionally, it can produce simple visual aids and interview-style phrasing.

When to use it

  • Preparing for coding interviews with clear, concise explanations
  • Documenting algorithms and implementations for teams
  • Teaching or learning algorithm concepts with stepwise clarity
  • Reviewing solutions to understand trade-offs and edge cases
  • Converting a working solution into an interview-friendly walkthrough

Best practices

  • Provide the full problem statement and the exact solution or pseudocode for accurate analysis
  • Choose depth based on audience: brief for quick review, detailed for teaching
  • Enable interviewStyle for spoken-answer phrasing and follow-up prompts
  • Request visuals when explaining complex data structures or traversals
  • Include expected input sizes to get precise complexity justification

Example use cases

  • Turn a LeetCode solution into a 5-minute interview explanation
  • Generate step-by-step documentation for a tricky dynamic programming solution
  • Compare BFS and DFS approaches for a graph problem, highlighting pros and cons
  • List common mistakes for pointer-based array manipulation and how to test them
  • Create annotated code walkthroughs in the desired programming language

FAQ

What inputs are required?

You must provide the problem description and the solution approach or code. Language and depth are optional but help tailor the output.

Can it produce visuals?

Yes. It can generate simple ASCII diagrams or descriptions for visuals. For richer graphics, pair the output with a drawing tool.