Steal My Claude Code Skills

You open a Jira ticket you got assigned this morning. You copy the description into Claude, hunt down the Figma links, paste in the acceptance criteria, spin up a branch, and by the time you're ready to write code it's already lunch. Then you spend the afternoon reviewing a diff that solved the wrong problem because nobody clarified what "streaming endpoint" meant in the ticket.

Five months of using Claude Code and I was still doing this setup every time. So I built a stack of skills and agents that handle the boring parts, and today I open-sourced them at github.com/akash-joshi/agent-skills.

There are five things worth stealing from this repo.

🎯 /ticket: hand it a ticket ID, get back a merge request

The invocation for this agent is one line:

/ticket ABC-123

The agent reads the ticket via any issue tracker, follows any Figma links and pulls the design context, reads linked Confluence pages, and scouts the codebase for reusable components and established patterns. It creates a git worktree for isolation, invokes /discuss to clarify anything ambiguous, writes a TDD plan to plan.md, and starts executing one commit at a time.

Each commit is a red-then-green cycle. Failing test first, minimum code to make it pass, verification command, commit. When the plan is done, it pushes the branch and opens the merge request via glab or gh. Your job is to review the diff.

The scope is bounded by the ticket. If a good idea shows up mid-execution that isn't in the acceptance criteria, it lands in a ## Deferred Ideas section instead of getting bolted onto the current work.

🛠️ AGENTS.md: the rules that stop it lying about testing

Without a rules file, the agent will cheerfully claim it ran the tests and skip them. AGENTS.md closes that loophole.

The core rules:

1. TDD is mandatory. Write the failing test, confirm it fails, write only enough code to pass. No planning "test commits" separate from "implementation commits". Every commit contains both, tested green.
2. Plans are files, not chat. Every plan lives in <ticket-id>-plan.md at the repo root. Each commit group has a red phase, green phase, and verification command. Status indicators (⬜ / ✅) update as the agent works.
3. Root cause, not symptom. Debugging is broken into phases. No stacking multiple fixes at once, no workarounds until Phase 1 (Root Cause Investigation) is actually done.
4. Autonomous unblocking. The agent runs curl, greps codebases, and pulls credentials without asking permission first. It only pauses for destructive actions.

Drop it at ~/AGENTS.md for global rules or at the repo root for project-specific ones.

💬 /discuss: catch ambiguity before the code

You've had this conversation. Agent finishes the ticket, you review the diff, and it built the wrong thing because the ticket said "streaming endpoint" and the agent assumed WebSockets when you wanted SSE.

/discuss runs before planning. It restates the scope in one sentence, greps the codebase for reusable assets and established patterns, and surfaces the gray areas that would meaningfully change the implementation. A good gray area is one where different answers would produce noticeably different code. Categories like "UI" or "Behaviour" aren't specific enough to qualify.

For the obvious calls it defaults inline. For the genuinely contested ones it asks via AskUserQuestion, batching up to four questions at once. Output is a CONTEXT.md file that plan mode and downstream agents consume.

Use it before /ticket on any non-trivial feature.

💰 /side-compact: pay Sonnet to summarise, not Fable

When your context fills up on Fable, /compact uses Fable to write the summary. Summarisation is grunt work. Sonnet or Haiku can do it for a fraction of the cost.

/side-compact

Hands the summarisation to Sonnet by default, writes it to a session summary file, and relaunches you into a fresh session seeded from it. Over a week of heavy use the savings add up faster than you'd expect.

Flags: -m haiku for cheaper still, -d brief for a shorter summary, -n to skip the relaunch.

🔍 Cold outreach skills: the non-coding half

Seven skills for client acquisition, distilled from Talha Asif's playbook for scaling an agency past $1M ARR.

• keyword-search finds people actively asking for your service on X, LinkedIn, and Telegram.
• cold-dm writes messages that get replies, with platform-specific formatting and volume targets.
• follow-up-sequences structures the multi-channel cadence that closes most deals on touch 3 to 5.
• prospecting-lists builds ICP-based lists systematically from directories and community research.
• discovery-calls frames the four-phase call structure: understand, prove, propose, close.
• profile-optimization turns your profile into a conversion surface.
• content-selling layers inbound content on top of outbound outreach.

Install

npx skills add akash-joshi/agent-skills

Works with Claude Code, Cursor, Codex CLI, and Gemini CLI. Auto-detects the agent and installs to the right directory. Grab individual skills too:

npx skills add akash-joshi/agent-skills --skill cold-dm keyword-search

Fork it, rip out what doesn't fit, layer your team's rules on top. Your skills should look like the way you actually work.