From Zero to One: Build Custom AI Skills to Strengthen Your Soft Power

Introduction

Writing long, logically‑tight prompts from scratch is inefficient. Experienced practitioners replace hand‑crafted prompts with reusable Skill definitions that capture logic, output format and constraints. This article demonstrates a “skill‑writer” that generates a book-analyzer skill, illustrating how AI can help construct AI Skills.

Soft power of a Skill

In this context, soft power is the ability to write high‑quality, reusable prompts. Hard skills refer to code implementation and API calls (e.g., MCP protocol). Soft skills refer to prompt architecture, logical decomposition and style definition. Packaging complex logic into a concrete Skill abstracts and preserves capability.

Case study: from skill-writer to book-analyzer

Define the skill‑writer : a meta‑skill whose responsibility is to generate high‑quality Skill definitions that follow a fixed framework (role, task, rules, reply template) from vague user requirements.

Invoke production : ask the skill-writer “I need a skill that can deeply dissect technical books, extract core logic, generate an action list and output a Xiaohongshu‑style share copy.”

Generate book-analyzer : the skill‑writer returns a structured prompt architecture including

Role : senior knowledge architect & content evaluation expert.

Rules : no fluff, must contain attribution analysis, copy must feel “online”.

Workflow : basic info → core logic → key insights → action list → share copy.

An example shows the author creating a test skill test‑red‑book, feeding an image to it, and confirming that the returned data matches the defined output‑template.md format.

Manual prompt construction without a skill‑writer

Role : assign a concrete expert identity (e.g., “you are a technical book reviewer with 10 years of experience”).

Context & Task : state the output goal clearly.

Constraints : list negative constraints (e.g., forbid clichés such as “In summary”).

Output format : provide a few‑shot example of the desired Markdown structure.

Crafting such prompts requires strong language ability and domain knowledge.

Dimensional comparison: manual prompt vs. skill generation

Consistency : manual prompts fluctuate with conversation context; skill‑generated prompts have a fixed structure and predictable style.

Production efficiency : manual prompts require rebuilding the structure each time; skill generation produces a new skill in seconds from business keywords.

Logical depth : manual prompts depend on the writer’s current thinking depth; skill‑generated prompts inherit the meta‑skill’s logical framework, starting at a high level.

Maintainability : manual prompts are scattered across dialogue logs and hard to reuse; skill files are independent, versionable assets that can be called repeatedly.

Developing soft‑power skills

Meta‑prompt library : create a personal structure‑master skill that converts messy ideas into structured Markdown files, teaching systematic problem decomposition.

From perception to measurement : embed self‑evaluation in a skill (e.g., “before outputting the report, verify that at least three concrete book cases are included; if not, re‑search and supplement”).

Modular design : split a large skill into sub‑skills such as data‑cleaning, logic‑extraction and copy‑polishing, then compose them to handle complex tasks.

Skill evolution: iteration and secondary development

Incremental additions : insert new steps into the existing Workflow (e.g., add “trend prediction” after “key insights”).

Boundary fixing : if the model hallucinates, add targeted negative constraints to Rules.

Style tuning : adjust the Role description to change tone.

Advanced optimization strategies for skill-writer

Feedback‑driven reshaping : feed a poorly performing book-analyzer report back to skill-writer with a command such as “improve the Rules and Workflow for stronger impact”.

Multidimensional parameterization : ask skill-writer to generate optional output‑depth levels (concise, standard, exhaustive) and switch automatically based on input.

AB testing & version management : keep multiple variants (e.g., book-analyzer‑v1, book-analyzer‑pro), compare their performance in real scenarios and merge the best.

Conclusion

Encoding human logical thinking as reusable Skill definitions turns the user from a passive prompt consumer into an “AI architect” who defines logical boundaries, orchestrates AI compute and builds sustainable AI soft‑power assets.

---
name: skill-writer
description: Guide users through creating Agent Skills for Claude Code. Use when the user wants to create, write, author, or design a new Skill, or needs help with SKILL.md files, frontmatter, or skill structure.
---
# Skill Writer
This Skill helps you create well‑structured Agent Skills for Claude Code that follow best practices and validation requirements.
## When to use this Skill
- Creating a new Agent Skill
- Writing or updating SKILL.md files
- Designing skill structure and frontmatter
- Troubleshooting skill discovery issues
- Converting existing prompts or workflows into Skills
## Instructions
### Step 1: Determine Skill scope
- Ask clarifying questions: what capability, when should Claude use it, required tools, personal vs team use.
- Keep it focused: one Skill = one capability (e.g., "PDF form filling" vs "Document processing").
### Step 2: Choose Skill location
- Personal Skills (`~/.claude/skills/`)
- Project Skills (`.claude/skills/`)
### Step 3: Create Skill structure
```bash
mkdir -p ~/.claude/skills/skill-name
mkdir -p .claude/skills/skill-name
```
Directory layout:
skill-name/
├── SKILL.md (required)
├── reference.md (optional)
├── examples.md (optional)
├── scripts/ (optional)
└── templates/ (optional)
### Step 4: Write SKILL.md frontmatter
```yaml
---
name: skill-name
description: Brief description of what this Skill does and when to use it
---
```
- name: lowercase, numbers, hyphens, max 64 chars, must match directory name
- description: max 1024 chars, include what it does AND when to use it, trigger words, file types, operations
### Step 5: Write effective descriptions
Good example:
```yaml
description: Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.
```
### Step 6: Structure the Skill content
```markdown
# Skill Name
Brief overview
## Quick start
Example to get started
## Instructions
1. First step with clear action
2. Second step with expected outcome
3. Handle edge cases
## Examples
Concrete usage examples
## Best practices
- Key conventions
- Common pitfalls
- When to use vs. not use
## Requirements
```bash
pip install package-name
```
## Advanced usage
See [reference.md](reference.md)
```
### Step 7: Add supporting files (optional)
- reference.md, examples.md, scripts/, templates/
### Step 8: Validate the Skill
- File structure, YAML validity, content quality, testing.
### Step 9: Test the Skill
1. Restart Claude Code
2. Ask a matching question (e.g., "Can you help me extract text from this PDF?")
3. Verify activation and correct behavior
### Step 10: Debug if needed
- Refine description, check file location, validate YAML, run `claude --debug`.