ai-agent-implementation-workflow

AI Community

Repo stars 0
Author repo skills-registry

Interpretation is structured for decision-making; original keeps the upstream SKILL.md unchanged.

Decide Fit First

Core job: Implement agentic behaviors safely with clear tool boundaries, deterministic contracts, and incremental verification across prom…
Best fit: Use it when the task has reusable inputs, steps, and validation criteria rather than a one-off answer.
Avoid forcing it: If the source lacks commands, platform support, or external-service evidence, keep those fields unknown instead of guessing.

Design Intent

Structure: The skill is organized around “What This Skill Produces”, “When to Use”, “Procedure”, “Quality Checks”, showing how the author expects the agent to judge fit, collect context, and produce verifiable output.
Trigger evidence: Prioritize the author’s wording around when to use it, what context to collect, and what output shape to produce.
Evidence boundary: Author text states facts, repository files prove commands and paths, and Fluxly only adds fit, limits, and usage judgment.

How To Use It

Inputs: Provide target material, scope, expected result, forbidden changes, and validation method.
Invocation: Name ai-agent-implementation-workflow directly; if the source includes slash commands, start with the command and then add task context.
Validation: Start small and check whether the result follows “What This Skill Produces / When to Use / Procedure” before expanding.

Boundaries And Review

Dependencies: It usually needs no extra API key, so start with a small validation task.
Permissions: Declared permissions include read / write; ask the agent to state file, command, and rollback boundaries before acting.
Quality bar: A useful result names the deliverable, evidence, and next action. Generic prose means the task needs tighter context.

AI Agent Implementation Workflow

What This Skill Produces

Use this skill to implement or update agent behavior with stable contracts. The expected result is:

explicit agent goal and decision boundaries
predictable tool invocation flow
schema-safe outputs for downstream consumers
graceful fallback when tools/providers fail
targeted tests or smoke checks proving behavior

When to Use

Use this skill when you need to:

add a new agent workflow
refine tool usage logic for an existing agent
fix agent output/schema instability
harden retry/fallback behavior in agent loops
align agent behavior across CLI/API/UI surfaces

Common trigger phrases:

"implement this agent behavior"
"add tool-calling to the agent"
"fix unstable agent responses"
"make the agent robust"
"agent output schema keeps breaking"

Procedure

Define contract first
- Lock input/output schema and required fields.
- Clarify what is best-effort vs required behavior.
Constrain tool boundaries
- List which tools can be called and for what reasons.
- Keep side-effecting actions explicit and auditable.
Implement minimal orchestration
- Prefer small deterministic control flow over deep branching.
- Make retries bounded and reason-aware.
Handle degraded mode intentionally
- Return actionable errors when hard requirements are missing.
- Use safe fallback only when it preserves contract meaning.
Verify behavior incrementally
- Add focused tests/smokes for primary path + fallback path.
- Confirm output schema is stable across paths.
Validate integration surface
- Ensure consuming endpoints/UI can parse new outputs.
- Avoid silent breaking changes in event/JSON structure.

Quality Checks

Before finishing, confirm that:

output schema is deterministic and documented
tool usage boundaries are explicit
retries/fallbacks are bounded and observable
failures are actionable, not silent
integration consumers remain compatible

Source: Bryan-Roe/Aria — distributed by TomeVault.

Fluxly profile Author and license come from source; runtime, permissions, and network are Fluxly detections or estimates

Fluxly category: AI
Author-declared agents: No explicit declaration found; this is not inferred or tested compatibility
Static check: 88 / 100 · heuristic scan, not runtime safety proof
Author / version / license: @tomevault-io · no license declared
Fluxly token estimate: Lean
Fluxly setup estimate: Plug-and-play
External API key: No requirement detected
Detected OS requirements: Unspecified
Runtime requirements: Unspecified
Detected file/system behavior: Read-only
Write / modify
Detected network behavior: Local-only
Install commands: None (reference only)

Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.

Heads up: 未限定 allowed-tools，默认拥有全部工具权限。

Output preview ai-agent-implementation-workflow.preview

The current SKILL.md does not define a fixed output example.

SKILL.md SKILL.md

# AI Agent Implementation Workflow

## What This Skill Produces

Use this skill to implement or update agent behavior with stable contracts. The expected result is:

- explicit agent goal and decision boundaries
- predictable tool invocation flow
- schema-safe outputs for downstream consumers
- graceful fallback when tools/providers fail
- targeted tests or smoke checks proving behavior

## When to Use

Use this skill when you need to:

- add a new agent workflow
- refine tool usage logic for an existing agent
- fix agent output/schema instability
- harden retry/fallback behavior in agent loops
- align agent behavior across CLI/API/UI surfaces

Common trigger phrases:

- "implement this agent behavior"
- "add tool-calling to the agent"
- "fix unstable agent responses"
- "make the agent robust"
- "agent output schema keeps breaking"

## Procedure

1. Define contract first
   - Lock input/output schema and required fields.
   - Clarify what is best-effort vs required behavior.

2. Constrain tool boundaries
   - List which tools can be called and for what reasons.
   - Keep side-effecting actions explicit and auditable.

3. Implement minimal orchestration
   - Prefer small deterministic control flow over deep branching.
   - Make retries bounded and reason-aware.

4. Handle degraded mode intentionally
   - Return actionable errors when hard requirements are missing.
   - Use safe fallback only when it preserves contract meaning.

5. Verify behavior incrementally
   - Add focused tests/smokes for primary path + fallback path.
   - Confirm output schema is stable across paths.

6. Validate integration surface
   - Ensure consuming endpoints/UI can parse new outputs.
   - Avoid silent breaking changes in event/JSON structure.

## Quality Checks

…

Evidence boundary and execution chain

Author text anchors workflow facts; Fluxly only indexes current sections, terms, files, and commands.

sections -> What This Skill Produces → When to Use → Procedure → Quality Checks
terms    -> Use this skill to implement or update agent behavior with stable contracts. · 1. Define contract first - Lock input/output schema and required fields. · 2. Constrain tool boundaries - List which tools can be called and for what reasons. · 3. Implement minimal orchestration - Prefer small deterministic control flow over deep branching. · 4. Handle degraded mode intentionally - Return actionable errors when hard requirements are missing. · 5. Verify behavior incrementally - Add focused tests/smokes for primary path + fallback path. · 6. Validate integration surface - Ensure consuming endpoints/UI can parse new outputs. · --- > Source: [Bryan-Roe/Aria](https://github.com/Bryan-Roe/Aria) — distributed by [TomeVault](https://tomevault.io).
files/cmd -> tools/providers · output/schema · retry/fallback · CLI/API/UI · input/output · tests/smokes · endpoints/UI · event/JSON
body sha256 -> 955dfe675356