Two Open-Source AI Skills I Built to Fix Daily Agent Friction

I use AI agents for most of my development work. Over time I noticed two patterns eating into my time: prompts that were too vague to produce useful output, and sessions that always started cold because the next agent had no context. I built two open-source skills to fix both.

Both are part of a free, MIT-licensed monorepo: github.com/knowingrohan/ai

1) refine-prompt — structure your intent before the agent runs

Rough prompts produce rough results. When a request lacks role, scope, and a definition of done, the agent fills the gaps with assumptions. The output is often usable but incomplete, and you end up re-running with more detail anyway.

refine-prompt adds that structure before any code is written. Run /refine-prompt in Claude Code (or skill: refine-prompt in any other agent) and describe your task in plain language. The skill rewrites it into a copy-paste-ready prompt with:

• An expert role for the agent to assume
• Concrete requirements extracted from your description
• Suggested local skills or tools to use
• A verification checklist the agent should satisfy before finishing

Before: ``` Add a Supabase migration for the expense-sharing feature ```

After: ``` Role: Senior Backend Engineer Task: Write a Supabase migration for a new expense_shares table. Add FK constraints to users and expenses, RLS policies that reject unauthenticated reads, and indexes on user_id and expense_id. Verification: Run supabase db reset, confirm no lint errors, verify RLS rejects unauthenticated reads with a unit test. ```

The agent gets a brief, requirements, and a definition of done. Re-run rate drops noticeably.

Resources:

• Skill source: https://github.com/knowingrohan/ai/tree/main/skills/refine-prompt
• Install: `npx skills add knowingrohan/ai --skill refine-prompt`

2) context-handoff — end every session with a resume prompt

Long sessions accumulate a lot of state: decisions made, trade-offs considered, files changed, tasks still open. When you close the session or switch to a different agent, all of that disappears. The next session starts from scratch.

`context-handoff` captures that state before it's gone. Run `/context-handoff` before ending a session and it generates a structured hand-off note:

• What was completed (specific and concrete)
• What is still pending, in priority order
• Key decisions and the reasoning behind them
• Files created or significantly modified
• A ready-to-paste resume prompt for the next agent

The resume prompt is the most useful part. Paste it as the first message in the next session and the agent picks up exactly where you left off — no re-explaining, no cold-start friction.

This also works across agent switches: Claude for planning and architecture, Codex for implementation, Devin for a specific integration. The hand-off note travels between them.

Resources:

• Skill source: https://github.com/knowingrohan/ai/tree/main/skills/context-handoff
• Install: `npx skills add knowingrohan/ai --skill context-handoff`

3) Both skills are agent-agnostic

The thing I care most about is that neither skill is tied to Claude Code. Both follow the shared `SKILL.md` format used by skills.sh, so they work with any agent that reads skill files.

| Agent | Reads From | |---|---| | Claude Code | `~/.claude/skills/` | | Codex | `.codex/skills/` | | Gemini CLI | `~/.gemini/skills/` | | Cursor / Windsurf | `.agents/skills/` | | Devin | Uploaded skill files |

Install both for the current project:

```sh npx skills add knowingrohan/ai --skill refine-prompt npx skills add knowingrohan/ai --skill context-handoff ```

Or install globally across all your local projects:

```sh npx skills add knowingrohan/ai --skill refine-prompt -g npx skills add knowingrohan/ai --skill context-handoff -g ```

Closing

These are small tools that solve narrow problems, but they have made a real difference in how smoothly I move through agent-heavy workflows. If you work with AI agents regularly and either of these problems sounds familiar, give them a try.

The monorepo is open to contributions. I am working on hooks and plugins next. If there is a workflow you want to cover, open an issue or reach out.