iii-http-invoked-functions
Registers external HTTP endpoints as iii functions using registerFunction(id, HttpInvocationConfig). Use when adapting legacy APIs, third-party webhooks, or immutable services into triggerable iii functions, especially when prompts ask for endpoint maps like { path, id } iterated into registerFunction calls.
59
67%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/iii-http-invoked-functions/SKILL.mdQuality
Discovery
85%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a well-structured skill description that clearly defines what it does and when to use it, with a specific technical niche that minimizes conflict risk. Its main weakness is that the trigger terms are quite technical and domain-specific, which could limit discoverability if users phrase their requests in more general terms. The description is concise and avoids fluff while providing actionable detail.
Suggestions
Add more natural/broader trigger terms like 'API integration', 'register endpoint', 'wrap external service', or 'function registration' to improve discoverability for users who may not use the exact technical terminology.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description lists concrete actions: 'Registers external HTTP endpoints as iii functions using registerFunction(id, HttpInvocationConfig)'. It specifies the exact function signature and the types of endpoints (legacy APIs, third-party webhooks, immutable services). | 3 / 3 |
Completeness | Clearly answers both 'what' (registers external HTTP endpoints as iii functions using registerFunction) and 'when' (adapting legacy APIs, third-party webhooks, or immutable services, especially when prompts ask for endpoint maps iterated into registerFunction calls). The 'Use when' clause is explicit. | 3 / 3 |
Trigger Term Quality | Includes some relevant terms like 'registerFunction', 'HTTP endpoints', 'webhooks', 'endpoint maps', and '{ path, id }'. However, the terms are fairly technical/niche ('iii functions', 'HttpInvocationConfig') and may not match how most users would naturally phrase requests. Missing broader terms like 'API integration', 'register endpoint', or 'function registration'. | 2 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with a very specific niche: registering HTTP endpoints as iii functions via registerFunction. The mention of HttpInvocationConfig, endpoint maps with { path, id }, and the specific use cases (legacy APIs, webhooks, immutable services) make it unlikely to conflict with other skills. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
50%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill provides a reasonable conceptual overview of HTTP-invoked functions with good structure around pattern selection, auth modes, and guardrails. However, it falls short on actionability by lacking a complete inline code example, relying instead on external reference files that cannot be verified. Redundancy between 'Pattern selection rules', 'When to Choose This', and 'When to Use' sections wastes tokens without adding clarity.
Suggestions
Add a complete, executable inline code example showing a minimal end-to-end registration and invocation flow (e.g., registering 2-3 endpoints from a descriptor list with auth config), rather than relying solely on external reference files.
Consolidate 'Pattern selection rules', 'When to Choose This', and 'When to Use' into a single decision section to eliminate redundancy and save tokens.
Add an explicit validation/verification step after registration (e.g., test invocation with expected response, error handling for failed registrations) to strengthen the workflow for this security-sensitive operation.
Move the generic 'Boundaries' section content into YAML frontmatter or remove it entirely, as it provides no skill-specific guidance.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is mostly efficient but has some redundancy. The 'When to Choose This' section largely repeats 'Pattern selection rules', and the 'When to Use' and 'Boundaries' sections at the bottom are generic boilerplate that adds little value. The auth modes and core model sections are appropriately lean. | 2 / 3 |
Actionability | The skill provides a 'Common shape' section with pseudocode-like patterns (e.g., `registerFunction(id, { url: base + path, method: 'POST' })`) but no complete, executable code example inline. It references external files for full implementations, but the body itself lacks a copy-paste-ready example showing a complete registration flow. | 2 / 3 |
Workflow Clarity | The 'Common shape' section outlines a sequence (register worker, build descriptor list, loop registration, add auth/metadata) but lacks explicit validation checkpoints. For a pattern involving security boundaries and external HTTP calls, there's no verification step (e.g., test invocation, validate config) or error recovery guidance. | 2 / 3 |
Progressive Disclosure | References to external files (JS, Python, Rust) are clearly signaled and one level deep, which is good. However, no bundle files were provided to verify these references exist, and the inline content could benefit from a brief executable example before pointing to references. The 'When to Use' and 'Boundaries' sections feel like they belong in frontmatter rather than the body. | 2 / 3 |
Total | 8 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- iii-hq/iii
- Commit
a7ebbbb
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.