There are already many posts about what agent skills are and how to create your own, so in this post I want to dive into the various skills I use to assist in development.

The Skills

Grill Me

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

To PRD

Turn the current conversation context into a PRD. Use when user wants to create a PRD from the current context.

This will simply take the current conversation and creates a PRD out of it, we do this to summarize the conversation so we can easily start a new context window with all information present

To Issue

Break a plan, spec, or PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices. Use when user wants to convert a plan into issues, create implementation tickets, or break down work into issues.

Another excellent skill by Matt Pocock. I modified the skill slightly to use the GitHub MCP to create issues based on a PRD or planning session.
But I often found that letting an agent implement those tasks it resulted in a large amount of code and that is why I added the to tasks skill

To Task

Break down a single GitHub issue into a sequential list of small implementation tasks, creating them as child sub-issues via the GitHub MCP.

This is simply a modification of the To Issue skill. The agent will gather information based on the provided issue and create small actionable tasks as subissues linked to the initial issue. With the implement skill this will lead to small pull requests with an average of 100-150 lines making it easy to understand and review the output.

Implement

Implement a task with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD.

This is a modified version of Matt's implement skill.
The skill will start with context gathering via the GitHub MCP and by reading related code.
Next a new branch will be checked out to isolate the changes and the implementation will be done a in red-green-refactor loop.

Discovery

Analyze and explore new or unfamiliar codebases to identify hot paths, architectural patterns, and high-complexity areas. Use when the user wants to understand a new repository, find frequently modified files, assess code difficulty, or analyze specific subdirectories of a project.

I use this rather sparingly but it has been useful a few times. Mostly it will highlight complex files or logic and introduce me to either a full repository or just a specified usecase.

Plan Sprint

Plan a sprint end-to-end by aligning scope, writing PRDs, creating GitHub issues, and breaking them into tasks. Orchestrates grill-me, prd, to-issue, and to-task skills. Use when planning a sprint, sprint planning, committing work for an iteration, or preparing a milestone in GitHub.

This is used to assist in planning a milestone or sprint and have actionable items over a longer period of time. This skill is reliant on the existence and the previously introduced skills and will orchestrate those depending on the defined readiness gates.

Summary

The skills I found the most useful are around the planning phase of a feature or project. While LLM code implementation still leaves much to be desired on larger tasks, it becomes useful if the tasks are small, boilerplate-heavy, or can be gated in other ways. To check out the skills yourself, you can find my repository here here.
Also, make sure to check out the original repository that inspired much of this workflow: Matt Pocock's skill repository