playbooks

home / skills / duc01226 / easyplatform / ck-help

ck-help skill

/.claude/skills/ck-help

This skill helps you obtain ClaudeKit guidance by running ck-help and presenting full output with contextual enhancements.

npx playbooks add skill duc01226/easyplatform --skill ck-help

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

Files (1)
SKILL.md
4.3 KB
---
name: ck-help
description: "[Tooling & Meta] ClaudeKit usage guide - just type naturally"
argument-hint: [category|command|task description]
infer: true
---

Think harder.
All-in-one ClaudeKit guide. Run the script and present output based on type markers.

## Summary

**Goal:** Provide ClaudeKit usage guidance by running `ck-help.py` and presenting results with contextual enhancements.

| Step | Action | Key Notes |
|------|--------|-----------|
| 1 | Translate arguments | Always translate `$ARGUMENTS` to English before script |
| 2 | Run script | `python .claude/scripts/ck-help.py "$ARGUMENTS"` |
| 3 | Detect output type | Read `@CK_OUTPUT_TYPE:` marker (docs/category/command/search/task) |
| 4 | Present output | Show COMPLETE script output verbatim, then add value-add context |

**Key Principles:**
- Never replace or summarize script output -- always show fully, then enhance
- `/plan` -> `/code` for planned work; `/cook` is standalone (never `/plan` -> `/cook`)
- Adjust presentation style based on output type marker

## Pre-Processing

**IMPORTANT: Always translate `$ARGUMENTS` to English before passing to script.**

The Python script only understands English keywords. If `$ARGUMENTS` is in another language:
1. Translate `$ARGUMENTS` to English
2. Pass the translated English string to the script

## Execution

```bash
python .claude/scripts/ck-help.py "$ARGUMENTS"
```

## Output Type Detection

The script outputs a type marker on the first line: `@CK_OUTPUT_TYPE:<type>`

**Read this marker and adjust your presentation accordingly:**

### `@CK_OUTPUT_TYPE:comprehensive-docs`

Full documentation (config, schema, setup guides).

**Presentation:**
1. Show the **COMPLETE** script output verbatim - every section, every code block
2. **THEN ADD** helpful context:
   - Real-world usage examples ("For example, if you're working on multiple projects...")
   - Common gotchas and tips ("Watch out for: ...")
   - Practical scenarios ("This is useful when...")
3. End with a specific follow-up question

**Example enhancement after showing full output:**
```
## Additional Tips

**When to use global vs local config:**
- Use global (~/.claude/.ck.json) for personal preferences like language, issue prefix style
- Use local (./.claude/.ck.json) for project-specific paths, naming conventions

**Common setup for teams:**
Each team member sets their locale globally, but projects share local config via git.

Need help setting up a specific configuration?
```

### `@CK_OUTPUT_TYPE:category-guide`

Workflow guides for command categories (fix, plan, cook, etc.).

**Presentation:**
1. Show the complete workflow and command list
2. **ADD** practical context:
   - When to use this workflow vs alternatives
   - Real example: "If you encounter a bug in authentication, start with..."
   - Transition tips between commands
3. Offer to help with a specific task

### `@CK_OUTPUT_TYPE:command-details`

Single command documentation.

**Presentation:**
1. Show full command info from script
2. **ADD**:
   - Concrete usage example with realistic input
   - When this command shines vs alternatives
   - Common flags or variations
3. Offer to run the command for them

### `@CK_OUTPUT_TYPE:search-results`

Search matches for a keyword.

**Presentation:**
1. Show all matches from script
2. **HELP** user navigate:
   - Group by relevance if many results
   - Suggest most likely match based on context
   - Offer to explain any specific command
3. Ask what they're trying to accomplish

### `@CK_OUTPUT_TYPE:task-recommendations`

Task-based command suggestions.

**Presentation:**
1. Show recommended commands from script
2. **EXPLAIN** the reasoning:
   - Why these commands fit the task
   - Suggested order of execution
   - What each step accomplishes
3. Offer to start with the first recommended command

## Key Principle

**Script output = foundation. Your additions = value-add.**

Never replace or summarize the script output. Always show it fully, then enhance with your knowledge and context.

## Important: Correct Workflows

- **`/plan` → `/code`**: Plan first, then execute the plan
- **`/cook`**: Standalone - plans internally, no separate `/plan` needed
- **NEVER** suggest `/plan` → `/cook` (cook has its own planning)

## IMPORTANT Task Planning Notes

- Always plan and break many small todo tasks
- Always add a final review todo task to review the works done at the end to find any fix or enhancement needed

Overview

This skill provides an all-in-one ClaudeKit usage guide that runs ck-help.py and presents its output with contextual enhancements. It enforces a strict workflow: translate arguments to English, run the script, read the output type marker, show the full script output verbatim, then add targeted, practical context. The goal is reliable, repeatable presentation of ClaudeKit help content with value-added guidance.

How this skill works

I translate any non-English arguments into English, execute python .claude/scripts/ck-help.py with those arguments, and read the first-line marker @CK_OUTPUT_TYPE:<type>. I always display the script output exactly as produced, then append tailored enhancements based on the reported output type (comprehensive-docs, category-guide, command-details, search-results, task-recommendations). The enhancement includes examples, gotchas, ordering advice, and a follow-up prompt.

When to use it

  • You want canonical ClaudeKit guidance or docs pulled directly from the tool.
  • You need command-level help with concrete examples and flags.
  • You want search results or task recommendations from the ClaudeKit knowledge base.
  • You’re onboarding teammates and need consistent presentation of workflows and rules.
  • You need to convert non-English queries into correct English inputs for the script.

Best practices

  • Always translate $ARGUMENTS to English before invoking the script; the script expects English keywords.
  • Never alter, truncate, or summarize the script output — show it completely, then add context.
  • Read the @CK_OUTPUT_TYPE marker and follow the specific presentation rules for that type.
  • Respect the workflow rules: use /plan → /code for planned work and use /cook only as a standalone action.
  • Break tasks into many small todos and include a final review task to validate and refine results.

Example use cases

  • Generate full configuration and setup docs: run with relevant args and present the comprehensive-docs output plus real-world config examples.
  • Inspect a single command: retrieve command-details, then provide a concrete usage example and common flags.
  • Search the knowledge base: run a keyword, show search-results, group matches by relevance and suggest likely hits.
  • Create task sequences: request task-recommendations and receive ordered commands with rationale and next steps.
  • Team onboarding: produce workflow guides per category-guide output and distribute consistent transition tips and gotchas.

FAQ

Do I need to translate every input manually?

Yes. Always translate $ARGUMENTS to English first because the script parses English keywords only. I handle the translated input format but the script requires English text.

Can I summarize the script output instead of showing it fully?

No. The script output must be shown verbatim. Any summarization or added context comes only after the complete output is displayed.