opencode-skillful

🥈Silver

Lazy load prompts on demand for OpenCode agents. Operations teams benefit by dynamically injecting skills during conversations. Connects to Claude agents, enhancing workflow automation.

26880Updated Today

Intermediate30min to implementautomation

Saves ~60 min per use

Quick InstallView Source

git clone https://github.com/zenobi-us/opencode-skillful.git

Works with:

Claude

Overview

About This Skill

Lazy load prompts on demand for OpenCode agents. Operations teams benefit by dynamically injecting skills during conversations. Connects to Claude agents, enhancing workflow automation.

How to Use

["Identify the skill you want to dynamically load (e.g., `data-processing`, `report-generation`). Ensure the skill is compatible with the opencode-skillful system.","In your OpenCode agent configuration, enable the opencode-skillful feature and specify the skill repository or directory where skills are stored. Example for Claude: `Enable opencode-skillful and set skill_repository to /path/to/skills`.","Use the prompt template to trigger on-demand skill loading. Replace `[SKILL_NAME]` with the skill you need (e.g., `report-generation`) and `[PARAMETERS]` with the required inputs (e.g., `template: monthly_report.md`, `data_source: sales_data.csv`).","Monitor the agent's response for confirmation of skill loading and execution. Review the structured output for results and next steps.","For advanced use, chain multiple skills by triggering subsequent prompts after the first skill completes. Example: After `data-processing`, trigger `report-generation` with the cleaned dataset as input."]

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/zenobi-us/opencode-skillful

Requirements

Claude Code or compatible AI agent
Works with: Claude

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Initialize the OpenCode agent with the following prompt template for dynamic skill injection: 'Act as an OpenCode agent with the ability to dynamically load and execute the [SKILL_NAME] skill when triggered by the user. The skill should be loaded on-demand using the opencode-skillful system. Once loaded, execute the skill with the following parameters: [PARAMETERS]. Respond with the results in a structured format.' Ensure the agent acknowledges the dynamic loading and confirms the skill execution.

Example Output

```json
{
  "status": "success",
  "skill_loaded": "data-processing",
  "execution_result": {
    "processed_records": 1247,
    "errors": 3,
    "avg_processing_time_ms": 45,
    "sample_output": [
      {"id": "REC-001", "status": "cleaned", "changes": ["removed_special_chars", "normalized_case"]},
      {"id": "REC-002", "status": "skipped", "reason": "duplicate_record"},
      {"id": "REC-003", "status": "cleaned", "changes": ["trimmed_whitespace"]}
    ]
  },
  "next_steps": [
    "Review the 3 errors for manual correction",
    "Log the processing metrics to the data pipeline dashboard",
    "Trigger downstream validation if all records are processed successfully"
  ]
}
```

The OpenCode agent dynamically loaded the `data-processing` skill using the opencode-skillful system. Upon receiving the user's request to clean a dataset of 1,250 records, the agent first verified the skill's availability and then executed it with the provided parameters (e.g., `input_dataset: sales_leads_q3.csv`, `validation_rules: standard_cleaning`). The skill processed the records in batches, logging errors for duplicates and special characters. The agent then formatted the results into a structured JSON response, including key metrics and actionable next steps for the operations team. This dynamic loading reduced the need for pre-loading all skills, optimizing memory usage and enabling faster response times during peak workloads.