Most developers use AI like autocomplete. The best developers use it like a software engineer.

Over the past year, AI coding assistants have become part of our daily workflow. Whether you're using ChatGPT, Claude Code, Codex, Cursor, or GitHub Copilot, they can generate code in seconds.

But here's the problem:

Most of us are still writing prompts like:

"Build me a login page."

or

"Fix this bug."

But what is the result?
Sometimes it's great. Sometimes it's a mess.
The difference isn't the model, it's the workflow.

After exploring Matt Pocock's open-source Skills repository, I realized something important:

AI doesn't just need instructions. It needs a process.

Instead of asking an AI to code, we should teach it how a software engineer works.

What are AI Skills?

Think of a Skill as a reusable engineering workflow.

Instead of giving AI a single prompt, you give it a structured way of thinking.

Examples include:

• Understanding requirements
• Writing a Product Requirements Document (PRD)
• Planning implementation
• Debugging systematically
• Improving architecture
• Creating tests before code
• Documenting handoffs

The result is significantly more consistent than one-off prompts.

Whether You're Building an MVP or Maintaining a Legacy System

These workflows are useful regardless of your experience.

🚀 Building an MVP

Before writing code:

• Validate the idea
• Clarify requirements
• Create a roadmap
• Break work into manageable tasks

Instead of rushing into implementation, you build with intention.

🏢 Working on an Existing Product

Most software engineers spend far more time maintaining software than creating greenfield projects.

Skills help you:

• Understand unfamiliar codebases
• Investigate bugs methodically
• Improve architecture incrementally
• Document decisions for the rest of the team

My Favorite Skills

1. Grill Me

Instead of generating code immediately, the AI starts asking questions.

Examples:

• Who is this feature for?
• What problem does it solve?
• What are the edge cases?
• What constraints exist?

It behaves like a senior engineer or product manager reviewing your idea.

2. Write a PRD

Turn a simple idea into a professional Product Requirements Document.

A good PRD includes:

• Goals
• User stories
• Scope
• Acceptance criteria
• Risks
• Success metrics

This is incredibly valuable for solo developers, startups, and open-source projects.

1. PRD → GitHub Issues

A document is useful.

Actionable tasks are even better.

This workflow automatically transforms a PRD into:

• Epics
• GitHub Issues
• Milestones
• Dependencies

Perfect for agile development.

1. TDD (Test-Driven Development)

Rather than jumping directly into implementation, the AI follows the classic cycle:

Write a failing test
Implement the feature
Make the test pass
Refactor

Even if you don't practice strict TDD today, this workflow naturally produces cleaner, safer code.

1. Diagnose

One of my favorites.

Instead of randomly changing code until something works, the AI:

• Reproduces the issue
• Builds hypotheses
• Validates each hypothesis
• Finds the root cause
• Proposes a solution

This is exactly how experienced engineers debug production issues.

1. Zoom Out

Sometimes AI focuses too much on a single file.

This workflow forces it to understand the bigger picture:

• Project structure
• Modules
• Dependencies
• Architecture
• Data flow

Especially useful when joining a new team or exploring a large repository.

1. Improve Architecture

Technical debt is inevitable.

This Skill reviews your project looking for:

• Large classes
• Tight coupling
• Duplicate logic
• Poor separation of concerns
• Better abstractions

It's like having an architecture review whenever you need one.

1. Handoff

Every engineer has ended a work session thinking:

"I'll remember where I left off."

You probably won't.

This workflow creates a clean handoff document including:

• Current progress
• Decisions made
• Remaining work
• Known issues
• Next steps

Perfect when switching devices, using different AI assistants, or collaborating with teammates.

A Workflow I Would Recommend

Instead of asking AI random questions throughout the day, I'd recommend something like this:

💡 New Idea
│
▼
🧠 Grill Me
│
▼
📝 Write a PRD
│
▼
📋 Generate GitHub Issues
│
▼
🧪 Build with TDD
│
▼
🐛 Diagnose Bugs
│
▼
🏗 Improve Architecture
│
▼
📄 Create a Handoff

This mirrors how experienced engineering teams actually work.

Why This Matters for Junior Developers

If you're just starting your software engineering journey, these workflows teach you how experienced engineers think, not just how they code.

You'll naturally learn:

1. Requirement analysis
2. Product thinking
3. Software architecture
4. Debugging
5. Testing
6. Documentation

These are the skills that accelerate your growth from junior to senior.

Why Senior Developers Should Care

Senior engineers aren't measured by how fast they type.

They're measured by how well they make decisions.

Using structured AI workflows helps:

• Reduce context switching
• Improve code quality
• Standardize development practices
• Make AI outputs more predictable
• Spend more time solving problems instead of rewriting generated code.

Final Thoughts

✅ AI won't replace software engineering principles.

✅ If anything, it makes them even more important.

✅ The better your process, the better your AI becomes.

✅ Stop asking your AI assistant to simply write code.

✅ Start teaching it how your engineering team works.

Your future self—and your teammates—will thank you.

What AI workflows have made the biggest difference in your daily development? I'd love to hear how you're using them.

This is a resume of this github repository, please check it out!!

npx skills@latest add mattpocock/skills