Skip to content
Skills Library
Programming · Research

api-documentation-discovery

/api-documentation-discovery

Use when APIs fail repeatedly with version-related errors (method not found, wrong arguments, unknown flag) or when about to use library APIs with uncertain knowledge - guides finding current, accurate documentation instead of guessing from training data

Licence
MIT
Last repository change
19.10.2026

Assessment and security

95/ 100Class: good
Format20 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
4
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 19.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when APIs fail repeatedly with version-related errors (method not found, wrong arguments, unknown flag) or when about to use library APIs with uncertain knowledge - guides finding current, accurate documentation instead of guessing from training data

Original author description

Use when APIs fail repeatedly with version-related errors (method not found, wrong arguments, unknown flag) or when about to use library APIs with uncertain knowledge - guides finding current, accurate documentation instead of guessing from training data

How it works

  1. Overview
  2. When to Use
  3. The Discovery Workflow
  4. Common Anti-Patterns
  5. Navigation: Language References
  6. Navigation: Framework References
  7. Red Flags - When You're About to Fail
  8. After Finding Documentation
  9. Real-World Impact
Original SKILL.md headings · 115 lines, 709 words
SKILL.md preview
---
name: api-documentation-discovery
description: Use when APIs fail repeatedly with version-related errors (method not found, wrong arguments, unknown flag) or when about to use library APIs with uncertain knowledge - guides finding current, accurate documentation instead of guessing from training data
---

# API Documentation Discovery

## Overview

When your training data conflicts with current API versions, STOP guessing and START discovering. This skill guides you to find current, accurate documentation using language-specific tools.

**Core principle:** Training data ages. Installed versions are truth. Use discovery tools to find what's actually there.

## When to Use

### Reactive Triggers (MUST use after these):
- ✅ 2+ failed attempts with same library/API
- ✅ Error patterns: "method not found", "wrong number of arguments", "unknown flag", "undefined method"
- ✅ Version mismatch symptoms in stack traces

### Proactive Red Flags (STOP and check docs when you notice):
- ⚠️ You're confident about API usage but haven't verified current version
- ⚠️ User is confident but their syntax keeps failing
- ⚠️ You're making "one more tweak" to syntax
- ⚠️ You're using phrases like "should work", "likely correct", "probably just"
- ⚠️ You're pattern-matching from training data without verification
- ⚠️ You're about to claim something is "documented" without checking

**When NOT to use:**
- First attempt with clear error message pointing to fix
- Errors unrelated to API usage (logic bugs, type errors in your code)

## The Discovery Workflow

### Step 1: STOP Guessing
Recognize the trigger. Don't make another attempt based on patterns or user confidence.

### Step 2: Identify Context
- What library/framework is failing? (check imports, stack traces, go.mod/Gemfile)
- What version is installed? (language tools show this)
- What operation are you trying? (the actual goal, not the syntax attempt)

### Step 3: Use Language Discovery Tools
Check language-specific reference for HOW to discover documentation:
- `references/go.md` - Go module exploration
- `references/ruby.md` - Ruby gem exploration

Follow progressive discovery: **docs → examples → source**

### Step 4: Load Framework Reference (if available)
If framework-specific reference exists, load it for curated patterns:
- `references/go/cobra.md` - Cobra CLI patterns
- `references/ruby/rails.md` - Rails patterns
- `references/ruby/karafka.md` - Karafka patterns

### Step 5: Verify Before Using
- Found API signature? Verify it matches your use case
- Found example? Adapt it, don't just copy pattern from memory
- Found docs? Read them, don't skim for confirmation

## Common Anti-Patterns

| Rationalization | Reality |
|----------------|---------|
| "User is confident, syntax is probably right" | User confidence ≠ current API. Verify. |
| "Training data shows this pattern" | Training data ages. Check installed version. |
| "Let me try one more variation" | Guessing wastes time. Check docs now. |
| "This is documented somewhere" | Then go READ it before claiming confidence. |
| "Should be simple, just tweak syntax" | Simplicity bias. Use discovery tools. |
| "We've spent enough time on this" | Sunk cost fallacy. 2 min checking docs beats 20 min guessing. |

## Navigation: Language References

**Available language discovery guides:**
- `references/go.md` - Go: `go doc`, `go list`, example/test scanning
- `references/ruby.md` - Ruby: `bundle info`, `ri`, gem exploration

**Path issues:** Some languages need tool managers (mise, asdf). If `go` or `bundle` not found, try `mise exec -- <command>`.

**Extending this skill:** To add a new language reference, see `references/WRITING.md` for principles and template.

## Navigation: Framework References

**Available framework cheat sheets:**
- `references/go/cobra.md` - Cobra CLI library patterns
- `references/ruby/rails.md` - Rails framework patterns (coming)
- `references/ruby/karafka.md` - Karafka framework patterns (coming)

## Red Flags - When You're About to Fail

**STOP immediately if you catch yourself:**
- Making confident API claims without checking current docs
- Accepting user's confident syntax without verification
- Trying "one more variation" based on pattern-matching
- Using phrases: "should work", "likely", "probably", "common pattern"
- Creating narrative about what "likely happened" without evidence
- Claiming something is "documented" without reading it

**All of these mean: Use discovery tools NOW.**

## After Finding Documentation

1. **Verify**: API signature matches your use case
2. **Adapt**: Use the pattern for your specific need
3. **Test**: Try the verified approach
4. **Update understanding**: Note what changed from your training data

## Real-World Impact

**Without this skill:**
- 15+ minutes guessing at syntax variations
- Confident claims based on outdated training data
- User frustration from repeated failures

**With this skill:**
- 2 minutes checking current docs
- Accurate API usage from installed version
- Fast resolution based on truth, not patterns
Files in this package (4)
  • SKILL.md 5 KB
  • references/WRITING.md 5 KB
  • references/go.md 3 KB
  • references/ruby.md 3 KB

Versions

The database has no other skills named api-documentation-discovery.

Database snapshot: 13.11.2026 · package version a8155975d337 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100context7
    Fetch up-to-date, version-specific library documentation and code examples from Context7. Use this skill whenever the user asks about a specific programming library, framework, or API, or when writing code that depends on a library. Replaces stale training-data knowledge with live docs.
  • 100documentation-lookup
    Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma).
  • 100context7
    Retrieve up-to-date documentation for software libraries, frameworks, and components via the Context7 API. This skill should be used when looking up documentation for any programming library or framework, finding code examples for specific APIs or features, verifying correct…
  • 100c7search
    Look up current, version-correct documentation and code examples for any library, framework or API through Context7 (the `c7search` CLI) instead of answering from memory. Use whenever the user asks how to use a library, wants a current code example, asks for the current or…
  • 100documentation
    Guide for writing technical documentation. Use when creating README files, API documentation, guides, or inline code documentation.
  • 96read-docs
    Read current official documentation, release notes and API references for libraries, frameworks, SDKs and APIs. Use before answering when the user names a version, is upgrading, pastes an error from a library or tool, or asks how to use, configure or migrate a specific library…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.