来自开源 Skill 仓库的提示模式

## Step 1: Create Design Philosophy

Create a `.md` file articulating a visual philosophy/aesthetic movement:
- Give the movement a NAME (e.g., "Chromatic Language", "Geometric Silence")
- Articulate through: space, form, color, scale, rhythm, composition
- This is a PHILOSOPHY, not a layout description
- Use craftsmanship language throughout

## Step 2: Deduce the Subtle Reference
Identify the conceptual thread from the original request.
This becomes the "soul" of the piece.

## Step 3: Express Philosophy on Canvas
Apply the philosophy visually. Museum-quality output.

## Step 1: Create the design
Make a beautiful poster based on the user's request.
Use good colors and layout.

## Final Step: Refinement

Examine your work critically. Use this exact thought:
"It isn't perfect enough. It must be pristine."

Look for:
- Alignment issues (off by even 1 pixel)
- Color harmony (does every color earn its place?)
- Typography kerning and weight
- Negative space balance
- Overall composition from 3 feet away

Make corrections. Do NOT skip this step.

## Optional: Review your work
If time permits, check for any issues.

## Reconnaissance-Then-Action Pattern

When testing any webpage:
1. **First:** Take a screenshot to see what the page actually looks like
2. **Second:** Inspect the DOM to identify precise selectors
3. **Third:** Identify the specific elements you need to interact with
4. **Fourth:** Execute your action using the identified selectors

NEVER click, type, or navigate without first observing the current state.

## Testing
1. Click the login button
2. Type the username
3. Submit the form

## Helper Scripts

### scripts/with_server.py
Manages server lifecycle for testing. Always run `--help` first:
```bash
python scripts/with_server.py --help

## Design Guidelines

Avoid these "AI slop" aesthetics:
- Excessive centered layouts (everything stacked vertically)
- Purple/blue gradient backgrounds (the default AI palette)
- Uniform rounded corners on everything
- Inter font everywhere
- Card-based layouts with no visual hierarchy
- Gratuitous animation with no purpose
- Stock photo placeholders

Instead:
- Use asymmetric layouts with intentional tension
- Choose colors that serve the content's mood
- Mix sharp and rounded corners deliberately
- Select typefaces that match the content's personality

## Design
Make it look professional and modern.

## Stage 2: Section-by-Section Building

For EACH section in the outline:

1. **Clarify:** "What's the main point you want this section to make?"
2. **Brainstorm:** Generate 3-5 possible approaches for this section
3. **Curate:** User picks the approach (or combines)
4. **Gap Check:** "What information am I missing to write this well?"
5. **Draft:** Write the section
6. **Refine:** User provides feedback, iterate until satisfied

Only move to the next section when the current one is approved.

## Writing
Generate the complete document based on the outline.
Present it to the user for review.

## Stage 3: Reader Testing

### With Sub-Agents (preferred)
Spawn a sub-agent with ONLY the document (no outline, no conversation history).
Give it these instructions:
- Read the document as if you've never seen it before
- Predict what each section will say BEFORE reading it (to test if structure is clear)
- Note any confusion, jargon, or missing context
- Rate each section's clarity on 1-5

### Without Sub-Agents (fallback)
Read the document as if for the first time.
For each section heading, predict its content before reading.
Note surprises — any surprise = a clarity issue.

## Review
After writing, re-read the document yourself and check for clarity issues.

1. Read both outputs without seeing skill content
2. Understand what the task asked for
3. Generate evaluation rubric (content + structure dimensions)
4. Evaluate each output against rubric
5. Check assertions (from test cases)
6. Determine winner with scores and reasoning
7. Write results as structured JSON

## Comparison
Run both versions, then decide which one you think is better
and explain why.

## How to use this skill

1. **Search for available tools:**
   Use RUBE_SEARCH_TOOLS with toolkit name "{service}" to discover available actions.

2. **Check and establish connection:**
   Use RUBE_MANAGE_CONNECTIONS to verify or create the API connection.
   If no connection exists, provide the setup URL to the user.

3. **Execute the action:**
   Use RUBE_MULTI_EXECUTE_TOOL to run the discovered action.

## Known Pitfalls
- Always search for tools first — tool names change between versions
- Always verify connection before execution — expired tokens cause silent failures

## Slack Integration
Call `chat.postMessage` with the channel ID and message text.
Use the bot token from environment variable SLACK_TOKEN.

## Twitter's Core Ranking Models

1. **Real-graph:** Predicts interaction probability between user pairs
2. **SimClusters:** Community detection via user-topic embedding spaces
3. **TwHIN:** Knowledge graph embeddings (user-tweet-author triples)
4. **Tweepcred:** PageRank-style reputation scoring on social graph

## Engagement Signals (Weighted)
- Explicit: likes (1x), replies (3x), retweets (5x), quotes (10x)
- Implicit: profile visits, link clicks, dwell time, bookmarks
- Negative: block (-100x), mute (-50x), "not interested" (-20x)

## Optimization Strategy
For each tweet, map to algorithm components:
1. Will this trigger Real-graph? (personal relevance)
2. Does it fit SimClusters? (community resonance)
3. What signals will it maximize? (engagement weights)

## How to write good tweets
- Be engaging
- Use hashtags
- Post at good times

## Step 1: Understand the Scope

Before organizing ANY files, ask these questions:
1. Which directory should I focus on? (specific path)
2. What's the main problem? (duplicates / messy naming / wrong locations / all of the above)
3. Are there any files or folders I should NEVER touch?
4. How aggressive should I be? (suggest only / move files / delete duplicates)

## Step 1: Organize
Look at the user's files and organize them.

## Example Output

### Available (.com)
| Domain | Status | Price |
|--------|--------|-------|
| codeflow.com | Available | ~$12/yr |
| devpulse.com | Available | ~$12/yr |

### Available (Alternative TLDs)
| Domain | Status | Price |
|--------|--------|-------|
| codeflow.dev | Available | ~$14/yr |
| codeflow.io | Available | ~$30/yr |

### Recommendations
**Top Pick:** codeflow.com — short, memorable, .com availability
**Runner-up:** devpulse.dev — modern TLD, developer audience signal

## Output Format
Return a table with columns: domain, status, price.
Group by availability.
Include recommendations.

## Workflow Selection

What does the user want?
├─ **Read/analyze** an existing document?
│  └─ Use `pandoc` to convert to markdown, then analyze
│
├─ **Create** a new document from scratch?
│  └─ Use docx-js (JavaScript) to build programmatically
│
├─ **Edit** an existing document (preserve formatting)?
│  └─ Unpack OOXML, edit XML directly, repack
│     (This is the only way to preserve styles, track changes, etc.)

## Creating Documents
Here's how to create Word documents...
(User who wants to EDIT is lost)

## Available Fonts

Use fonts from the `./canvas-fonts` directory. Available families:
- Playfair Display (Regular, Bold, Italic)
- Space Mono (Regular, Bold)
- Crimson Text (Regular, Italic)
- ...

Always use absolute paths resolved from the skill directory.
Do NOT download fonts from the internet.

## Fonts
Download a font from Google Fonts that matches the design.
Use the URL: https://fonts.googleapis.com/css2?family=...

## Quality Assurance

After generating slides:
1. Spawn a sub-agent with screenshot capability
2. Sub-agent opens each slide and takes screenshots
3. Sub-agent checks against these criteria:
   - No text overflow outside slide boundaries
   - No repeated layouts on consecutive slides
   - No accent lines under titles (anti-pattern)
   - Color palette consistency
   - Font size readability
4. Report issues → fix → re-verify

## Quality Check
Review the generated slide XML to verify layout is correct.
Check that no text exceeds the slide boundaries.

## Critical Rule: Formulas, Never Hardcoded Values

NEVER put a calculated number directly in a cell.
ALWAYS use an Excel formula.

✅ Cell C2: =A2*B2 (calculates price × quantity)
❌ Cell C2: 150 (hardcoded result of 10 × 15)

After creating the spreadsheet, MANDATORY: run LibreOffice recalculation
to verify all formulas produce correct results.

## Spreadsheet
Fill in the total column with the calculated values.
For row 2, the total is 150. For row 3, the total is 230.

## Language Detection

Determine the user's language:
├─ Python imports (`import anthropic`, `from anthropic`) → Read `python/claude-api/README.md`
├─ TypeScript imports (`import Anthropic`, `from @anthropic-ai/sdk`) → Read `typescript/claude-api/README.md`
├─ Java → Read `java/claude-api.md`
├─ Go → Read `go/claude-api.md`
├─ Ruby → Read `ruby/claude-api.md`
├─ C# → Read `csharp/claude-api.md`
├─ PHP → Read `php/claude-api.md`
├─ cURL / no code → Read `curl/examples.md`
└─ Unknown → Ask user

Always load `shared/models.md` regardless of language.

## API Documentation
Here is the complete Claude API reference for all languages:
[... Python docs ...] [... TypeScript docs ...] [... Java docs ...]
[... Go docs ...] [... Ruby docs ...]

## Surface Selection

What is the user building?
├─ **Single API call** (classification, extraction, Q&A)
│  └─ Load: language-specific basic examples
├─ **Multi-step workflow** (pipelines, chains)
│  └─ Load: tool-use docs + streaming docs
├─ **Autonomous agent** (tool loop, planning)
│  └─ Load: tool-use + agent design docs
├─ **Managed agent** (Anthropic-hosted)
│  └─ Load: managed-agents docs (beta)

## Claude API
Use messages.create() to call the Claude API.
Pass your prompt in the messages array.

## Running Evaluations

1. **Create test cases** (`evals.json`):
   - 5+ prompts covering different scenarios
   - Each with expectations (MUST contain, MUST NOT contain, behavioral checks)

2. **Run tests:** Spawn sub-agent per test case
   - Sub-agent executes the skill with the test prompt
   - Captures full transcript + output

3. **Grade:** Spawn grader sub-agent
   - Reads expectations + transcript
   - Extracts claims, verifies each against evidence
   - PASS/FAIL per expectation with reasoning

4. **Analyze:** Spawn analyzer sub-agent
   - Surfaces per-assertion patterns (which expectations fail most?)
   - Cross-eval patterns (are failures correlated?)
   - Generates improvement suggestions

5. **Improve:** Apply suggestions to SKILL.md
   - Re-run evals to verify improvement
   - Benchmark: compare old vs new versions

## Testing
Try a few prompts and see if the output looks good.
If it does, ship it.

## Non-Anthropic Detection (BEFORE anything else)

If the code imports or uses any of these, STOP and say
"This skill is for the Anthropic/Claude API. Your code uses {provider}.":

- `import openai` / `from openai`
- `import { OpenAI }` / `@google/generative-ai`
- `langchain` with non-Anthropic models
- Any `OPENAI_API_KEY` references

Do NOT try to adapt the code to work with Claude.
Do NOT suggest replacing the provider.
Just inform and stop.

## Getting Started
Help the user write code that calls the Claude API.