DEV Community: z z

10 Git Commands I Wish I Learned Sooner

z z — Mon, 15 Jun 2026 09:32:29 +0000

We all learn Git the hard way. You start with add, commit, push — and that works until the day you accidentally commit to main or delete a branch you meant to keep.

Here are 10 Git commands I discovered way later than I should have. Each one saved me from a real mess.

1. `git switch` — The Safe Checkout

I used git checkout for everything: switching branches, restoring files, creating new branches. Until one day I ran:

git checkout some-file.txt

expecting to switch to a branch, and instead wiped my working directory changes.

git switch separates branch switching from file restoration:

git switch feature-branch      # switch branches
git switch -c new-feature      # create and switch

git restore handles the file side:

git restore some-file.txt      # discard uncommitted changes

Two commands, one job each. No more accidental wipes.

2. `git log --oneline --graph` — See the Story

Plain git log dumps a wall of text. Add --oneline --graph and you see the actual branch topology:

git log --oneline --graph --all --decorate

* 7a3f92e (HEAD -> main) fix: handle null pointer
| * a8d2c11 (feature-x) feat: add retry logic
|/
* b4e3391 chore: bump deps

I use --all because branches you're not on matter too. Onboard this as an alias:

git config --global alias.tree "log --oneline --graph --all --decorate"
git tree

3. `git commit --amend` — Edit Without Clutter

Pushed a typo in the last commit message? Forgot to stage that one file?

git add forgotten-file.py
git commit --amend --no-edit      # add file without changing message
git commit --amend -m "Better message"  # fix the message

⚠️ Only amend commits you haven't pushed yet. Once pushed, amend rewrites history and everyone who pulled will hate you.

4. `git stash push -m "description"` — Named Stashes

Without a message, git stash creates nameless entries. Three stashes later you have no idea which is which.

git stash push -m "WIP: login refactor"
git stash push -m "debug logging experiment"
git stash list
# stash@{0}: On main: debug logging experiment
# stash@{1}: On main: WIP: login refactor

git stash pop stash@{1}

I now write a description every single time — saves me 5 minutes of "which stash was that" every week.

5. `git rebase -i` — Clean History Before You Share

Your branch has 7 commits that say "wip", "fix", "fix again". Before merging, squash them into one meaningful commit:

git rebase -i HEAD~7

In the editor, change pick to squash (or just s) for the commits you want to merge upward. Keep the first commit's message.

I rebase before every merge. The result is a linear, readable history that your future self and your teammates will thank you for.

6. `git bisect` — Find the Bug Automatically

A feature that worked last week is broken today. You have 50 commits between "worked" and "broken".

git bisect start
git bisect bad                 # current commit is broken
git bisect good abc123         # this commit worked

# Git checks out a commit in the middle.
# You test it:
git bisect good                # if it works
git bisect bad                 # if it's broken

# Repeat 4-5 times. Git finds the exact commit.
git bisect reset

bisect runs a binary search. 50 commits → ~6 checks. 500 commits → ~9 checks. I use this monthly and it always finds the culprit.

Automate it if you have a test command:

git bisect run npm test

7. `git worktree` — Work on Two Branches at Once

You're deep in feature-x and someone says "urgent hotfix on main".

Instead of stashing or force-closing your editor:

git worktree add ../hotfix-fix main
cd ../hotfix-fix
# fix the bug, commit, push
cd ..
git worktree remove ../hotfix-fix

Each worktree is a full checkout in its own directory. Open it in another editor tab, work on it, switch back. No stash, no context loss.

I keep 2-3 worktrees active during a typical dev day.

8. `git diff --cached` — Review Before You Commit

git diff shows unstaged changes. But I want to review what I'm about to commit:

git diff --cached

This shows only the staged diff. It's replaced by the git commit -v experience:

git commit -v    # opens editor with diff in the message area

See exactly what goes in before it goes in. Catches half-baked code every time.

9. `git clean -nd` — Preview Destructive Deletes

Untracked files accumulate: build artifacts, .env.bak, node_modules you somehow regenerated.

git clean -nd
# Would remove .env.bak
# Would remove dist/

The -n flag is a dry run. -d targets directories. When you're sure:

git clean -fd

I never run git clean without -n first. Too many stories of someone nuking a folder they needed two days ago.

10. `git blame --ignore-revs-file` — Skip Formatting Commits

git blame is the first thing I reach for when I see weird code. But auto-formatters and mass renames pollute the blame, pointing at the person who ran prettier instead of the person who wrote the bug.

# Save a file listing commits that are "noise"
echo "abc123def" > .git-blame-ignore-revs
git blame --ignore-revs-file .git-blame-ignore-revs main.py

Commit your .git-blame-ignore-revs file to the repo so everyone benefits. GitHub even respects it natively when viewing blame on pull requests.

These 10 commands won't make you a Git guru overnight. But they'll save you from the specific, painful moments we all hit: accidental deletions, messy histories, broken branches, and wasted hours tracking down bugs.

Start with one: alias git tree and run it on your current project. See your branches differently.

Have a Git command that made you say "I wish I learned this sooner"? Drop it in the comments.

I Built 10 MCP Servers in a Weekend — Here's the Template I Wish I Had Starting Out

z z — Thu, 11 Jun 2026 10:18:45 +0000

MCP (Model Context Protocol) is everywhere now. Every week there's a new server for GitHub, for databases, for APIs you've never heard of.

But when I first started, I spent more time reading docs than writing code. The protocol isn't hard — it's just that every tutorial either shows you a toy example or dumps you straight into the full TypeScript SDK without explaining the basics.

So I built a template. Then I built 10 servers off it in one weekend.

Here's what I learned, and the template I now use for every MCP server.

The Core Insight

An MCP server is just a stdio or HTTP server that speaks JSON-RPC. That's it.

# Minimal MCP server in 20 lines
import sys, json

def handle_request(msg):
    if msg.get("method") == "tools/list":
        return {"tools": [{"name": "hello", "description": "Say hello", "inputSchema": {"type": "object", "properties": {}}}]}
    elif msg.get("method") == "tools/call" and msg.get("params", {}).get("name") == "hello":
        return {"content": [{"type": "text", "text": "Hello from MCP!"}]}
    return {"error": "unknown method"}

for line in sys.stdin:
    msg = json.loads(line.strip())
    result = handle_request(msg)
    sys.stdout.write(json.dumps(result) + "\n")
    sys.stdout.flush()

That's a working MCP server. 20 lines.

The Template I Actually Use

After 10 iterations, this is the structure that scales:

mcp-server/
├── server.py        # JSON-RPC handler + tool registry
├── tools/           # One file per tool
│   ├── __init__.py
│   ├── search.py
│   └── transform.py
├── config.py        # Env vars, defaults
└── requirements.txt

Key principles:

One file per tool group — keeps things testable
Tool registry pattern — register tools with a decorator, no routing boilerplate
Stdio first, HTTP later — start with stdio for local dev, add HTTP transport when you need remote access

What I Actually Built

Over the weekend I made:

A GitHub issues fetcher
A SQL query builder (safe, no injection)
A markdown-to-HTML converter
A web scraper tool
A JSON transformer
A code formatter wrapper
A weather data server
A text summarizer
A URL shortener
A Docker log parser

Tools that an AI assistant can actually use during development.

The Hardest Part Wasn't the Code

It was packaging and distribution. Getting the server from "works on my machine" to "anyone can install and run it" takes more effort than writing the server itself.

That's why I put everything I learned into a starter kit — the template, the 10 servers, the packaging scripts, and a setup guide so you can go from zero to deployed in 30 minutes.

The Fastest Way to Start

If you want to build MCP servers without the packaging headache:

1. MCP Server Starter Kit — The template, 10 example servers, deployment scripts, and a step-by-step guide. $0 minimum (pay what you want).

2. AI Developer Toolkit — If you're building AI workflows, this has the prompts and patterns I use daily. $9.99.

3. Claude Code Skills Pack — 50 production-tested prompts for Claude Code. $9.99.

I write about MCP, AI tooling, and developer workflows. Follow me for more practical guides — no fluff, just things that actually work.

I Used 500 ChatGPT Prompts for 30 Days — Here's What I Learned About Getting AI to Actually Help

z z — Wed, 10 Jun 2026 11:37:50 +0000

For the past month, I ran an experiment. Instead of typing whatever came to mind into ChatGPT, I prepared prompts in advance — specific ones for specific situations.

Not "help me write an email" prompts. I'm talking about prompts designed for the exact moment you need them: when you're stuck on a work problem, when you need to have a difficult conversation, when you're planning a trip and don't know where to start.

Here's what I found.

The Problem with "Freeform" ChatGPT

Most people use ChatGPT like a search engine with opinions. They type a vague question, get a vague answer, and conclude "AI isn't that useful."

The truth is: ChatGPT is an amplifier. Garbage in, garbage out. Specific in, gold out.

When I stopped asking "help me be more productive" and started asking "create a weekly planning template with columns for must-do, should-do, nice-to-do, and delegated tasks" — the output went from generic to immediately usable.

The 10 Areas Where Prompts Made a Real Difference

After testing across 10 categories of daily life, here's where structured prompts had the most impact:

1. Writing & Content Creation
Pre-written prompts for blog posts, emails, social media, and scripts saved me 2+ hours per week. Instead of staring at a blank screen, I paste a prompt and get a structured first draft in 30 seconds.

2. Productivity Systems
The biggest surprise. Prompts for creating SOPs, designing workflows, and breaking down complex projects were more useful than any productivity app I've tried.

3. Career & Professional Growth
Interview prep prompts, salary negotiation scripts, and performance review templates. These are conversations where you can't afford to improvise.

4. Personal Finance
Budget planning, debt repayment strategies, investment research frameworks. A well-structured prompt for financial analysis beats scrolling through Reddit threads.

5. Health & Fitness
Meal prep plans, workout routines, sleep hygiene checklists. The prompts helped me be consistent because they removed the "what should I do?" decision every day.

6. Relationships & Communication
This surprised me most. Prompts for difficult conversations, apologies, and boundary-setting helped me prepare for talks I'd been avoiding for weeks.

7-10. Learning, Travel, Mental Health, Creativity
Each area benefited from the same principle: a good prompt is a thinking framework, not just a question.

Does This Scale?

Yes — but only if the prompts are specific enough. A generic "100 productivity prompts" list won't help because you won't use them in the moment.

The key is coverage. You need prompts for the situations you actually face, organized so you can find them when you need them. A prompt you can find in 5 seconds is useful. A prompt buried in a PDF you have to search through is useless.

What I Built

After the 30 days, I compiled the 500 prompts that actually worked into a structured guide organized by category. Each prompt is designed to be copy-pasted with minimal editing.

It covers writing, productivity, health, finance, career, learning, relationships, travel, mental health, and creativity — 50 prompts per category.

The Bottom Line

ChatGPT is useless if you ask it nothing. It's mildly useful if you ask it random things. It's genuinely valuable if you build a system of prompts that match your actual needs.

The effort isn't in using AI. It's in preparing how you use it. And that prep work, done once, pays for itself many times over.

If you want the full set of 500 prompts I used during this experiment, they're available in my profile. But even if you don't grab them — take 30 minutes this week to write down 10 situations where you wish you had better answers, and write a specific prompt for each one. You'll thank yourself later.

💡 **Tools I use:* MCP Server Starter Kit (PWYW) • 500 ChatGPT Prompts ($12.99) • AI Developer Toolkit ($9.99)*

I Spent a Month Pair-Programming with Claude Code — Here's What Actually Worked

z z — Wed, 10 Jun 2026 10:25:51 +0000

Six weeks ago I started using Claude Code as my daily pair programmer. Not for demos, not for "look what AI can do" — for actual, ship-to-production work.

The internet is full of hot takes. Either AI will replace all developers, or it's a toy that writes broken code. After a month of real use, neither is true. Here's what actually works.

The Setup

I run Claude Code from my terminal with a few custom MCP servers for web search, file operations, and database queries. No IDE plugin, no chat interface — just /usr/bin/claude and a terminal split.

Key config decisions:

Always start with a clear goal file (goal.md) before any session
Use MCP tools for context (search docs, check logs, read schemas) — raw Claude Code without tools hallucinates too much
Break every task into 15-minute chunks max

Where It Shines

1. Refactoring with confidence. I had a 600-line Express.js route handler that had grown organically over two years. "Split this into controller/service/repository layers, preserve all existing behavior, don't break the session middleware." Claude Code did it in one pass. I reviewed the diff in 10 minutes. Zero regressions.

The trick: be specific about what NOT to change. "Don't touch the error handling pattern in line 120-180" is better than "refactor this properly".

2. Writing boilerplate I'd normally procrastinate. Database migrations, CRUD routes for a new model, API tests for an existing endpoint — these are the tasks I'd estimate as "2 hours" and take 4 because I get distracted. Claude Code finishes them in one shot with 90% accuracy. The last 10% is trivial fixes.

3. Debugging cryptic errors. A WASM WebGL project was rendering a black screen with zero console errors. I pasted the shader code and build config into Claude. It spotted a missing @interpolate(flat) qualifier in the WGSL vertex shader that I'd stared at for an hour. Saved me an evening.

Where It Falls Short

Complex multi-step logic. "Implement a new authentication flow with OAuth, session management, rate limiting, and audit logging" — Claude Code produces working code but misses edge cases. CSRF token rotation on password change. Rate limit headers in error responses. Things a senior dev knows from experience.

Design decisions. Claude Code is great at "how" but bad at "whether". Should we use WebSocket or SSE for this feature? Should this be a new microservice or an endpoint in the existing API? It will happily implement whichever approach you suggest, even if it's wrong.

Large refactors with no tests. Without a test suite to validate against, Claude Code makes plausible-looking changes that break silently. Always have at least one integration test that exercises the critical path before letting it loose.

The Workflow That Works

My current routine:

Goal.md first — Write 3-5 sentences about what needs to happen, including explicit constraints
Claude Code takes the first pass — I review the diff, not the conversation
I fix the subtle stuff — Error handling, edge cases, naming conventions
Commit with a good message — Claude Code writes the commit message boilerplate, I add the "why"

The biggest productivity gain isn't speed. It's flow state. When Claude Code handles the mechanical parts, I stay in the zone for the parts that matter — architecture decisions, edge case thinking, code review.

The Honest Bottom Line

Claude Code saves me about 2-3 hours per day, mostly on tasks I'd procrastinate anyway. It doesn't eliminate the need for senior engineers — it makes them more effective by removing the grunt work.

The developers who get the most value aren't the ones who use it for everything. They're the ones who know exactly when to use it and when to type the code themselves.

I've been collecting the specific prompts and workflows that work best in practice. If you're curious, I wrote up my complete set of reusable Claude Code configurations and MCP server setups.

💡 **Tools I use:* MCP Server Starter Kit (PWYW) • 500 ChatGPT Prompts ($12.99) • AI Developer Toolkit ($9.99)*

10 MCP Servers That Actually Improve Your Development Workflow in 2026

z z — Wed, 10 Jun 2026 09:23:19 +0000

If you've been following the AI-assisted development space, you've heard about the Model Context Protocol (MCP). But let's be honest—most MCP server lists are either too abstract or filled with niche tools you'll never use. In 2026, the ecosystem has matured, and I've curated 10 MCP servers that deliver real, measurable improvements to your daily coding workflow.

Each entry includes:

What it does
Why it's useful (with a concrete scenario)
Example config (using the standard .mcp.json or claude_desktop_config.json)

Let's dive in.

1. GitHub MCP Server (by modelcontextprotocol)

What it does: Full read/write access to GitHub repos—issues, PRs, code reviews, and releases.

Why useful: Instead of switching between your IDE and GitHub, your AI assistant can create a PR, request a review, and merge after CI passes—all from a single prompt.

Example config:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxxxxxxxxxx"
      }
      }
    }
}

Scenario: "Create a new branch, add a fix for issue #42, push, and open a draft PR with a description."

2. Filesystem MCP Server

What it does: Read, write, search, and manipulate files and directories on your local machine.

Why useful: Your AI can now scaffold an entire project structure, rename files in bulk, or refactor code across multiple files without manual intervention.

Example config:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"],
      "env": {
        "ALLOWED_DIRS": "/home/user/projects"
      }
    }
  }
}

Scenario: "Create a Next.js project with this folder structure, add a components folder, and move all page files into a pages directory."

3. PostgreSQL MCP Server

What it does: Connect to PostgreSQL databases, run queries, and return results.

Why useful: Debugging SQL queries or exploring a production database becomes a conversation. You can ask "Show me the last 10 orders with user details" and get the result directly.

Example config:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    }
  }
}

Scenario: "Find all users who signed up in the last 7 days and haven't placed an order."

4. Docker MCP Server

What it does: Manage Docker containers, images, volumes, and compose stacks.

Why useful: No more copying and pasting Docker commands. Your assistant can spin up a dev environment, run tests inside a container, and tear it down when done.

Example config:

{
  "mcpServers": {
    "docker": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-docker"]
    }
  }
}

Scenario: "Build the Dockerfile in this directory, tag it as myapp:latest, and run it with port mapping 3000:3000."

5. Supabase MCP Server

What it does: Full CRUD access to Supabase projects—database, storage, auth, and Edge Functions.

Why useful: If you're building with Supabase, your AI can create tables, write RLS policies, upload files, and manage user authentication directly.

Example config:

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server"],
      "env": {
        "SUPABASE_URL": "https://yourproject.supabase.co",
        "SUPABASE_SERVICE_KEY": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
      }
    }
  }
}

Scenario: "Create a 'profiles' table with columns for username, avatar_url, and bio. Add Row Level Security so users can only update their own profile."

6. Redis MCP Server

What it does: Interact with Redis instances—keys, sets, streams, pub/sub, and more.

Why useful: Debugging caching issues or inspecting session data becomes trivial. You can ask "What's the current value of the rate limit key for user 123?" and get an instant answer.

Example config:

{
  "mcpServers": {
    "redis": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-redis"],
      "env": {
        "REDIS_URL": "redis://localhost:6379"
      }
    }
  }
}

Scenario: "Delete all keys matching 'session:*' that are older than 24 hours."

7. Playwright MCP Server

What it does: Headless browser automation—click, type, screenshot, and extract data from web pages.

Why useful: Your AI can test UI interactions, take screenshots for documentation, or scrape data without you writing a single line of Playwright code.

Example config:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-playwright"]
    }
  }
}

Scenario: "Go to localhost:3000, click the login button, fill in the form with test credentials, and take a screenshot of the dashboard."

8. Slack MCP Server

What it does: Send messages, read channels, search history, and post to threads.

Why useful: Your AI can notify your team when a deployment finishes, fetch context from past conversations, or even help you draft a message.

Example config:

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxx",
        "SLACK_TEAM_ID": "TXXXXXXXXXX"
      }
    }
  }
}

Scenario: "Post a message in #deployments saying 'Frontend v2.3.1 deployed to production successfully.'"

9. Linear MCP Server

What it does: Full access to Linear issues, projects, teams, and cycles.

Why useful: If you use Linear for project management, your AI can create issues, update statuses, assign tasks, and generate sprint reports.

Example config:

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-linear"],
      "env": {
        "LINEAR_API_KEY": "lin_api_xxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

Scenario: "Create a new issue in the 'Frontend' team for the current cycle titled 'Fix mobile nav overflow' with priority P1."

10. Jira MCP Server

What it does: Interact with Jira—issues, sprints, boards, and projects.

Why useful: For teams stuck in Jira, this is a lifesaver. Your AI can transition issues, update custom fields, or generate burndown chart data.

Example config:

{
  "mcpServers": {
    "jira": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-jira"],
      "env": {
        "JIRA_URL": "https://yourdomain.atlassian.net",
        "JIRA_EMAIL": "you@example.com",
        "JIRA_API_TOKEN": "xxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

Scenario: "Move all issues in the 'In Progress' column to 'Done' and add a comment that they were completed in the current sprint."

Bonus: How to Combine MCP Servers

The real power emerges when you chain servers. For example:

Use GitHub to create a PR
Use Slack to notify the team
Use Linear to update the associated issue

All from a single prompt: "Deploy the hotfix, update the Linear ticket, and let the team know in Slack."

Getting Started

Most MCP servers in this list are one npx command away from working. Pick the two or three that solve your biggest pain points and start with those. The MCP ecosystem is still evolving, but investing time now means your AI assistant becomes genuinely useful—not just a code generator, but a teammate that interacts with your entire development stack.

I publish developer tool templates and skills packs at zhirenhun.gumroad.com. If you found this useful, check out my Claude Code Skills Pack — 50 production-ready prompts for AI-assisted development.

10 Git Mistakes That Waste Hours — And How to Fix Them in Seconds

z z — Mon, 08 Jun 2026 08:25:56 +0000

Here are 10 Git mistakes I've made (or cleaned up for teammates) that cost real time — and the exact commands to fix them.

1. Committed to the wrong branch

You're on main, made changes, committed. Then you realize: this should have been a feature branch.

# Create the branch you meant to use, point it at your commit
git branch feature/new-api
# Reset main back to where it was
git reset --hard origin/main
# Switch to the new branch
git checkout feature/new-api

git branch <name> creates a branch at your current commit without switching. Then git reset --hard moves your current branch back.

2. "I need the last commit's changes but not the commit itself"

You made a commit but want to undo the commit while keeping the changes in your working directory:

git reset --soft HEAD~1

--soft moves the branch pointer back one commit but leaves all changes staged. You can re-commit them differently, split them, or discard.

3. Accidentally committed a massive file

You added a 200MB video file, committed it, and now git push hangs forever.

# Remove the file from ALL commits (rewrites history)
git filter-branch --index-filter 'git rm --cached --ignore-unmatch path/to/bigfile.mp4' HEAD
# Force push
git push origin --force

Better yet, catch it before commit with a pre-commit hook that blocks files over a threshold.

4. "I need that commit I made before I reset"

You ran git reset --hard and now the commit is gone. Not really — Git keeps it for 30 days:

# Find your "lost" commit
git reflog
# You'll see something like: HEAD@{2}: commit: Added user authentication
# Restore it
git cherry-pick HEAD@{2}
# Or checkout the whole state
git checkout HEAD@{2}

The reflog is your safety net. It records every HEAD movement for 30 days.

5. Committed with the wrong author name

Your commit shows "Unknown" or your work email instead of your GitHub email:

# Fix the last commit's author
git commit --amend --author="Your Name <email@example.com>" --no-edit

# Fix multiple commits
git rebase -i HEAD~5
# Mark commits as "edit", then for each one run:
git commit --amend --author="... " --no-edit && git rebase --continue

Fix your global config to prevent this: git config --global user.name "..." and git config --global user.email "...".

6. Merge conflict nightmare

A merge created conflicts in 15 files and you're not sure which changes to keep:

# Abort the merge entirely
git merge --abort

# Or use a visual diff tool
git mergetool

# Or accept all "theirs" or "ours" for specific files
git checkout --theirs path/to/file.js   # Accept incoming changes
git checkout --ours path/to/file.js     # Accept your changes

When in doubt, abort and re-approach with a cleaner strategy.

7. "I need to undo a pushed commit"

You pushed a bad commit and need to undo it without rewriting public history:

# Create a new commit that reverses the bad one
git revert HEAD
# Push the revert
git push origin main

git revert is safe for shared branches because it doesn't rewrite history. Use git reset only for commits that haven't been pushed.

8. "I deleted a branch I still need"

# Find the deleted branch's last commit hash
git reflog
# Look for "Branch: deleted feature/login" or the last commit message
# Restore the branch at that commit
git branch feature/login <commit-hash>

If you haven't garbage-collected, the commits are still there.

9. "I committed on main instead of a branch" (the panic version)

You made several commits on main before realizing:

# Create branch at current position
git branch feature/new-api
# Reset main to origin (safe because we have a branch pointing to our work)
git reset --hard origin/main

The branch you created preserves all your commits. Main is clean.

10. "The commit message is terrible"

git commit --amend -m "Actually descriptive commit message"

Only works for the most recent commit. For older commits, use git rebase -i and mark them as "reword".

The One Command That Saves All of This

I got tired of remembering these commands, so I wrote a Claude Code skill called Git Rescue that handles all 10 scenarios automatically. You invoke it with /git-rescue and it walks you through the recovery step by step.

The full pack includes this plus 49 other skills for code review, debugging, security, and refactoring.

50 Claude Code Skills Pack — $9.99

Git's safety net (reflog, the 30-day commit retention) is incredibly forgiving once you know it. What Git mistakes have you made? Drop them in the comments.

I Wrote 50 Claude Code Prompts and Used Them for a Week -- Here's What Actually Works

z z — Mon, 08 Jun 2026 03:32:27 +0000

Last week I did something dumb: I sat down and wrote 50 Claude Code prompts in one sitting.

Halfway through I was sure most would never get used. But I finished and forced myself to use them for a week.

7 Skills That Actually Saved Hours

1. Code Review Assistant (saved ~3h)

On a 400-line PR it caught 2 security issues I would have missed.

2. Bug Investigator (saved ~2h)

Structured debugging instead of guessing.

3. Dependency Audit (saved ~1h)

2 CVEs, 8 unused deps (21 MB) in a 3-year old project.

4. Auto Commit Messages (saved ~30m)

15 commits, 2 minutes saved each.

5. Test Generator (saved ~2h)

5-8 test cases per function in seconds.

6. Refactoring Planner (saved ~1h)

Dependency-ordered plan, just execute.

7. Performance Audit (saved ~30m)

Unoptimized 3 MB hero image found.

What I Learned

Analysis skills (review, debug, audit) beat generation skills. They save hours, not minutes.

Skills are habit. Hardest part was remembering to use them.

Free: https://github.com/zhirenhun-stack/claude-code-skills

Full pack with 40 more skills available on Gumroad.

Drop your most-used prompts in the comments.

💡 **Tools I use:* MCP Server Starter Kit (PWYW) • 500 ChatGPT Prompts ($12.99) • AI Developer Toolkit ($9.99)*

I Wrote 50 Claude Code Prompts and Used Them for a Week -- Here's What Actually Works

z z — Mon, 08 Jun 2026 03:23:10 +0000

Last week I did something dumb: I sat down and wrote 50 Claude Code prompts in one sitting.

Halfway through I was sure most of them would never get used. But I finished, pushed them to GitHub, and made myself use them for an entire week -- no ad-hoc prompting allowed.

The result surprised me. Some skills were life-changing. Others were useless. Here is the honest breakdown.

The Methodology

I categorized the 50 skills into 5 types: Analysis (12), Generation (14), Debugging (8), Planning (10), Maintenance (6).

Rule: every time I hit a task, I must use a skill file or admit I did not have one.

The 7 That Actually Saved Me Hours

1. Code Review Assistant (saved ~3h)

This was the biggest surprise. I usually review PRs by gut feel -- scan the diff, look for obvious bugs, approve. The Code Review skill forced me to be systematic:

On a 400-line PR it caught 2 security issues I would have missed. That alone justified the experiment.

2. Bug Investigator (saved ~2h)

Instead of pasting errors and asking "why?", this skill forces you to provide: error message, file context, hypothesis.

3. Dependency Audit (saved ~1h)

Scanned a 3-year old Node project. Found 2 CVEs, 8 unused devDependencies (21 MB).

4. Auto Commit Messages (saved ~30m)

Saves 2 minutes per commit. Over 15 commits in a week that is 30 minutes.

5. Test Generator (saved ~2h)

Generates 5-8 test cases per function in seconds.

6. Refactoring Planner (saved ~1h)

Reads the function, identifies extraction candidates, outputs a dependency-ordered plan.

7. Performance Audit (saved ~30m)

Found an unoptimized 3 MB hero image and a render-blocking script.

The Ones I Never Touched

About 8 out of 50 were "not this week" -- Database Migrations, API Documentation, CI/CD Pipeline.

What I Learned

The ROI is in the analysis skills. Code review, bug investigation, dependency audit -- these are high-judgment tasks where Claude thoroughness beats speed.

Skills are habit, not technology. The hardest part was not writing the prompts -- it was remembering to use them.

Should You Do This?

If you use Claude Code daily, writing 5-10 custom skills for your most common tasks will pay back in 2 weeks.

I published all 50 skills on GitHub (free): https://github.com/zhirenhun-stack/claude-code-skills

The full pack has 40 more covering security, DevOps, and cloud infrastructure -- available on Gumroad if you find the free ones useful.

What skills would you add? Drop your most-used prompts in the comments.

💡 **Tools I use:* MCP Server Starter Kit (PWYW) • 500 ChatGPT Prompts ($12.99) • AI Developer Toolkit ($9.99)*

50 Reusable Claude Code Skills That'll Save You Hours Every Week

z z — Sun, 07 Jun 2026 13:55:49 +0000

Every developer I know has that one task they do so often it's muscle memory — but still manual. You type the same git log incantation, the same review checklist, the same debugging incantation. You copy-paste your review template from an old PR. You re-explain "please analyze this crash" to the LLM for the fifth time this week.

What if you never had to ask twice?

Claude Code has a skills system that lets you save reusable instructions as named files. Once saved, you invoke them with a slash command — /skill-name — and the entire instruction set loads instantly. The result? Your best workflows become one keystroke away.

After curating 50 skills across real production projects, here are the five most impactful ones — with the actual code and scenarios that make them indispensable.

1. Git Rescue — `/git-rescue`

The scenario: You've been hacking for an hour, made 14 commits on the wrong branch, and now git log looks like a crime scene. You need to clean it up without losing work — and fast.

The skill file (git-rescue.skill.md):

# Git Rescue

You are a Git recovery specialist. The user has a messy git history
and needs to clean it up.

Rules:
- Always confirm destructive commands (reset --hard, push --force)
  before execution
- Prefer `git rebase -i` over `reset` when commits have meaningful messages
- Suggest `git reflog` first when the user says "I lost work"
- For "wrong branch" scenarios: suggest cherry-pick or merge, not replay

Workflow:
1. Run `git log --oneline -20` to assess the situation
2. Run `git branch -a` to check for recovery targets
3. Propose a plan before executing
4. After cleanup, verify with `git log --oneline -5`

Why it saves hours: That moment of panic when you git reset --hard the wrong thing is uniquely costly. A well-structured skill turns panic into a calm, step-by-step checklist. It's saved my team over an hour of collective "oh no" time.

2. Code Review — `/code-review`

The scenario: Someone drops a 1,200-line PR on your desk at 4 PM. You need to review it thoroughly, but you also need to be done before dinner.

The skill file (code-review.skill.md):

# Code Review

You are a senior code reviewer. Focus on correctness, security,
and maintainability — not style.

Checklist (run in order):
1. `git diff main...HEAD --stat` — understand scope
2. `git diff main...HEAD` — full diff walkthrough
3. For each changed file, flag:
   - Unsanitized user input → SQL injection / XSS risk
   - Hardcoded secrets or API keys
   - Error paths that swallow exceptions
   - State mutations inside pure functions
4. Security: check for `eval`, `exec`, raw SQL concat, missing auth
5. Performance: N+1 queries, O(n²) in hot paths, unnecessary allocations
6. Summarize: list blocking issues first, then nits, then praise

Pro tip: The best review skills have three output sections — "Blocking," "Should Fix," and "Nit" — so the author knows exactly what to prioritise.

Why it saves hours: A junior reviewer spends 45 minutes on a PR and misses three security issues. A senior spends 10 minutes and catches all of them. This skill closes that gap.

3. Refactor Helper — `/refactor-helper`

The scenario: You have a 300-line "utils" function that grew organically over two years. Everyone is afraid to touch it. But now you need to add a feature, and you can't stomach adding another parameter.

The skill file (refactor-helper.skill.md):

# Refactor Helper

You are a code refactoring specialist. Your goal is to decompose
large functions into smaller, testable units without changing
external behaviour.

Rules:
1. Start by reading the full function — `cat` or read the file
2. Identify: pure computations, I/O, error handling, side effects
3. Group related logic into candidate helper functions
4. For each candidate, write a minimal signature and docstring
5. After extracting, verify: `diff` the before/after on sample inputs
6. Never change behaviour — if the output changes, revert and retry
7. Suggest test cases for each extracted function

Real-world example: I used this on a 280-line Python function that parsed 3 different log formats. The skill extracted 4 focused functions in under 5 minutes. Every one passed the existing test suite on the first run. The original author — who'd been "meaning to refactor" for six months — was speechless.

4. Debug Analyzer — `/debug-analyzer`

The scenario: A test fails intermittently. The stack trace is 40 lines deep. console.log shows it enters the right branch, but the output is wrong. You've been staring at it for an hour.

The skill file (debug-analyzer.skill.md):

# Debug Analyzer

You are a debugging specialist. The user has a failing test or a
runtime error. Walk through it systematically.

Workflow:
1. Read the full error output and traceback
2. Identify: exception type, what was expected vs what happened
3. Trace the data flow: where does the incorrect value originate?
4. Check the three most common sources:
   - Off-by-one errors in loops or array slicing
   - Async timing (missing await, race condition)
   - Mutable state sharing (object mutated in place)
5. Propose a hypothesis → minimal reproduction → fix → verify
6. If stuck after 3 attempts, suggest adding structured logging

Why it saves hours: Debugging is the most unpredictable time sink in software. A systematic approach — exactly what this skill enforces — turns "stare at the problem" into "follow the checklist." The structure alone saves at least 30 minutes per session.

5. Test Generator — `/test-generator`

The scenario: You just wrote a new module with 12 exported functions. You know you should write tests. You also know you won't — unless it's painless.

The skill file (test-generator.skill.md):

# Test Generator

You are a test generation specialist. Given a source file, produce
comprehensive unit tests.

Rules:
- One `describe` block per exported function
- Cover: happy path, error path, edge cases (empty/null/zero/boundary)
- Mock external dependencies (network calls, file I/O, DB)
- Use the same test framework as the project (detect from package.json / config)
- Write assertions that test behaviour, not implementation
- After generating, run: `npx vitest run --reporter=verbose`

Output format:
- Create `__tests__/<filename>.test.js` (or adjacent `.test.ts`)
- Include a header comment with the source file path and date

The result: I generated 45 unit tests for a 400-line TypeScript module in one /test-generator call. They caught three edge cases I hadn't thought of — and the whole thing took under 2 minutes.

Building Your Own Skill Library

These five skills took me about 20 minutes total to write. The ROI is absurd: every time you use one, you save more time than it cost to create.

Here's how to start:

Create a ~/.claude/skills/ directory (or wherever your Claude Code config lives)
Write your first skill — start with the task you do most often and hate the most
Name it descriptively — git-rescue.skill.md, deploy-check.skill.md, migration-rollback.skill.md
Run /skill-name in Claude Code to use it
Iterate — after 3 uses, you'll know exactly what to add or remove

The trick is to keep skills small and focused. One task per file. A clear trigger ("when this happens"), a checklist, and a verification step.

Pro tip: Version-control your skills directory. A shared .claude/skills/ repo in your organisation means every team member benefits from the collective debugging and review expertise of the entire group. Onboarding new engineers goes from "here's our wiki" to "here's our skills repo."

Your future self — the one staring at a cryptic stack trace at 6 PM on a Friday — will thank you.

👉 Check out the full pack of 50 ready-to-use Claude Code skills on Gumroad: https://zhirenhun.gumroad.com/l/claude-code-skills

This pack covers Git workflows, code review, debugging, refactoring, testing, deployment checks, database migrations, incident response, and more — each one battle-tested in real production environments.

5 AI Coding Prompts That Changed How I Ship Software

z z — Sun, 07 Jun 2026 13:36:10 +0000

1|---
2|title: "5 AI Coding Prompts That Changed How I Ship Software"
3|published: true
4|description: "After shipping 10+ projects with AI assistance, here are the 5 prompts that actually save me hours every week"
5|tags: ai, productivity, programming, webdev
6|---
7|
8|After a year of using AI coding agents daily, I've learned one thing the hard way: the prompt is the product.
9|
10|A vague prompt gets you boilerplate. A sharp prompt gets you production code.
11|
12|Here are the 5 prompts I use every day that actually move the needle.
13|
14|---
15|
16|## 1. The Context Sandwich
17|
18|Most developers dump a task and expect magic. Instead:
19|
20|

21|CONTEXT: This is a Next.js 14 app with Prisma + PostgreSQL.
22|I have a schema for "orders" with status enum (pending, paid, shipped, cancelled).
23|GOAL: Create an API route that filters orders by status, with pagination (20 per page).
24|CONSTRAINTS: Must use cursor-based pagination. Must include total count.
25|OUTPUT: Full route code + curl examples.
26|```


27|
28|Why it works: You're telling the AI **where to work, what to build, and how to verify**. No guesswork.
29|
30|---
31|
32|## 2. The Refactor Blueprint
33|
34|Instead of "refactor this file":
35|
36|

37|FILE: components/UserDashboard.tsx (342 lines)
38|PROBLEM: Too many responsibilities — renders profile, orders list, and settings.
39|TARGET: Split into 3 files: UserProfile.tsx, OrderList.tsx, UserSettings.tsx
40|OUTPUT: Each file with full imports, keeping the same API shape so the parent doesn't break.
41|VERIFY: The original import path ./UserDashboard should still export the same component (as a thin wrapper).
42|```

43|
44|The AI generates the split, and the verification step catches common mistakes like missing exports or broken imports.
45|
46|---
47|
48|## 3. The Error-First Debug
49|
50|When debugging, most people paste an error and ask "why?". Better:
51|
52|

53|ERROR: TypeError: Cannot read properties of undefined (reading 'map')
54|FILE: src/hooks/useProducts.ts, line 42
55|CONTEXT: This is called after a fetch from /api/products. The API returns { data: Product[] } but sometimes data is null.
56|HYPOTHESIS: The error happens when data is null before the fetch completes.
57|FIX: Add a guard clause. Also check: is the loading state being handled in the component?
58|OUTPUT: The fix + why it happened + how to prevent it next time.
59|```


60|
61|The hypothesis gives the AI a starting point. The "also check" catches secondary issues.
62|
63|---
64|
65|## 4. The Test Generator
66|
67|Tests are boring but necessary. This prompt makes them fast:
68|
69|

81|
82|I get 5-8 test cases in seconds, covering the happy path and the edge cases I'd forget to write myself.
83|
84|---
85|
86|## 5. The Documentation First
87|
88|Before writing any code for a new feature, I prompt:
89|
90|

91|FEATURE: Add a "compare products" sidebar that lets users select 2-4 products and see a side-by-side comparison table.
92|DESIGN DOC: Write a brief spec covering:
93|  - Component tree (what renders what)
94|  - State management (selected products, comparison data)
95|  - API shape (what the comparison endpoint returns)
96|  - Loading / empty / error states
97|  - Mobile vs desktop layout
98|KEEP IT SHORT: One paragraph per section. Bullet points for states.
99|```


100|
101|This alone has saved me from building the wrong thing at least 5 times. The AI surfaces edge cases you haven't thought of, and you catch them before writing a single line of implementation code.
102|
103|---
104|
105|## Why This Matters
106|
107|The difference between a junior and a senior using AI tools isn't the tool — it's the **prompt architecture**. These 5 patterns alone cut my implementation time by about 40% on most features.
108|
109|I've compiled 50 more battle-tested prompts like these — covering debugging, refactoring, testing, documentation, and architecture — into a Claude Code Skills Pack. Each skill is a reusable prompt template you can drop into your workflow.
110|
111|👉 [50 Claude Code Skills Pack – Prompts That Ship](https://zhirenhun.gumroad.com/l/izhcu)
112|
113|The free version gives you 10 skills to try. If they save you even one debugging session, it's paid for itself.
114|
115|---
116|
117|*What prompts have you found that consistently save time? Drop them in the comments — I'm always looking to level up my kit.*
118|

I Just Made 50 Claude Code Prompts Free — Here's Why

z z — Thu, 04 Jun 2026 14:30:37 +0000

Claude Code is incredible at coding. But let's be honest — most of us use it the same way: type a question, get an answer, move on.

You are leaving 80% of its capability on the table.

I spent weeks building a collection of 50 specific, battle-tested prompts that turn Claude Code into specialized tools:

A code reviewer that catches SQL injection, memory leaks, and race conditions
A bug investigator that traces root causes instead of guessing
A performance auditor that finds bottlenecks in your stack
A refactoring planner that shows you exactly which files to touch (in what order)
A dependency auditor that flags security risks before they reach production

The Problem

Most developers use Claude Code with ad-hoc prompts. "Review this code" — and you get a shallow pass. "Debug this" — and you get random guesses.

The secret is specificity. A prompt like:

You are a senior security engineer. Review this diff for:
1. SQL injection in string interpolation
2. XSS in unescaped template variables
3. Memory leaks from unclosed event listeners
4. Race conditions in async operations

For each finding, provide: severity (🔴/🟡/🟢), file:line, exploit scenario, and exact fix code.

This is not the same as "review this code." The difference is night and day.

What I Built

I compiled 50 such prompts into single-file markdown documents. Each one is a specific tool:

#	Skill	What It Does
1	Auto Commit Messages	Generates conventional commits from staged changes
2	Code Review Assistant	Catches bugs, security holes, design issues
3	Project Context Builder	Understands any codebase in 2 minutes
4	Test Generator	Creates comprehensive test suites
5	Bug Investigator	Root cause analysis, not random fixes
6	API Documentation	Generates docs from source code
7	Database Migrations	Safe schema change planning
8	Refactoring Planner	Incremental, reversible refactoring
9	Dependency Audit	Security + license + bloat analysis
10	Performance Audit	Find bottlenecks and config issues
... and 40 more covering CI/CD, Docker, security, monitoring, and production ops

How to Use

git clone https://github.com/zhirenhun-stack/claude-code-skills.git
claude -p "$(cat skills/02-code-review.md)" -p "$(git diff main)"

Why Free?

I believe these prompts should be accessible to everyone who codes. The free GitHub repo has 10 prompts. The full pack of 50 is pay-what-you-want ($0 minimum) — you decide.

If you find even 2-3 prompts that save you time, share them with a teammate. That is the only "payment" I ask for.

Real Example: Dependency Audit

Yesterday I ran the Dependency Audit on a 3-year-old Node.js project:

🔴 HIGH — CVE-2024-XXXX in lodash@4.17.15
  → Server-side prototype pollution via crafted JSON
  → Fix: npm install lodash@4.17.21

🟡 MEDIUM — Leftpad-style pattern in 3 dependencies
  → These packages have 1 maintainer and 0 test coverage
  → Consider inlining or replacing

🟢 LOW — 8 unused devDependencies
  → Removed: node-sass, gulp, coffeescript (21 MB saved)

It took 10 seconds. It would have taken 30 minutes to audit manually.

Get It

Free (10 prompts): github.com/zhirenhun-stack/claude-code-skills
Full Pack (50 prompts): Gumroad — Pay What You Want ($0+)

Drop a comment if there is a specific skill you want me to add. I am actively maintaining this collection.

P.S. If this saves you even one debugging session, star the repo. It helps others find it.

Build Your Own MCP Server in 5 Minutes — TypeScript Starter Template

z z — Wed, 03 Jun 2026 12:29:14 +0000

I've been building MCP servers for my own projects, and I realized something: everyone keeps reimplementing the same boilerplate. File reads, directory listings, grep — you write them once, then again in the next server.

So I put together a minimal MCP Server Starter in TypeScript. Three tools to get you started:

// Example from src/index.ts
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "read_file",
      description: "Read contents of a text file",
      inputSchema: {
        type: "object",
        properties: {
          path: { type: "string", description: "Absolute path to the file" }
        }
      }
    },
    // list_directory, grep_search — same pattern
  ]
}));

Quick Start

npm install
npm run build
npm start

Then add to Claude Desktop config:

{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["/path/to/mcp-server-starter/dist/index.js"]
    }
  }
}

Why MCP?

MCP (Model Context Protocol) is Anthropic's open protocol that lets LLMs talk to external tools. Write your server once and any MCP-aware client can use it — Claude Desktop, Cursor, VS Code, and more.

Instead of writing a custom integration for every LLM, you write your MCP server once and it works everywhere. Standard I/O transport — no HTTP server, no open ports, no Docker required.

What's Inside (Free Version)

Tool	What it does
`read_file`	Read any text file
`list_directory`	List files in a folder with sizes
`grep_search`	Search for text across your codebase

All TypeScript with the official MCP SDK. Compiles to a single Node entry point. MIT licensed.

Pro Version ($9.99)

The Pro Kit adds:

File metadata operations — stat, permissions, timestamps
API integration — fetch any URL with timeout handling
Web search — DuckDuckGo integration with LLM-optimized formatting
Dockerfile — containerized deployment
VPS deploy script — one-command deployment with systemd + rsync
Commercial license

Get Started

GitHub (free): github.com/zhirenhun-stack/mcp-server-starter
Live demo / landing page: zhirenhun-stack.github.io/mcp-server-starter
Pro Kit ($9.99): Gumroad

Also check out git-copilot — AI-free conventional commit message generator, and Claude Code Skills — battle-tested skills for developers.

DEV Community: z z

10 Git Commands I Wish I Learned Sooner

1. git switch — The Safe Checkout

2. git log --oneline --graph — See the Story

3. git commit --amend — Edit Without Clutter

4. git stash push -m "description" — Named Stashes

5. git rebase -i — Clean History Before You Share

6. git bisect — Find the Bug Automatically

7. git worktree — Work on Two Branches at Once

8. git diff --cached — Review Before You Commit

9. git clean -nd — Preview Destructive Deletes

10. git blame --ignore-revs-file — Skip Formatting Commits

I Built 10 MCP Servers in a Weekend — Here's the Template I Wish I Had Starting Out

The Core Insight

The Template I Actually Use

What I Actually Built

The Hardest Part Wasn't the Code

The Fastest Way to Start

I Used 500 ChatGPT Prompts for 30 Days — Here's What I Learned About Getting AI to Actually Help

I Spent a Month Pair-Programming with Claude Code — Here's What Actually Worked

10 MCP Servers That Actually Improve Your Development Workflow in 2026

1. GitHub MCP Server (by modelcontextprotocol)

2. Filesystem MCP Server

3. PostgreSQL MCP Server

4. Docker MCP Server

5. Supabase MCP Server

6. Redis MCP Server

7. Playwright MCP Server

8. Slack MCP Server

9. Linear MCP Server

10. Jira MCP Server

Bonus: How to Combine MCP Servers

Getting Started

10 Git Mistakes That Waste Hours — And How to Fix Them in Seconds

1. Committed to the wrong branch

2. "I need the last commit's changes but not the commit itself"

3. Accidentally committed a massive file

4. "I need that commit I made before I reset"

5. Committed with the wrong author name

6. Merge conflict nightmare

7. "I need to undo a pushed commit"

8. "I deleted a branch I still need"

9. "I committed on main instead of a branch" (the panic version)

10. "The commit message is terrible"

The One Command That Saves All of This

I Wrote 50 Claude Code Prompts and Used Them for a Week -- Here's What Actually Works

7 Skills That Actually Saved Hours

1. Code Review Assistant (saved ~3h)

2. Bug Investigator (saved ~2h)

3. Dependency Audit (saved ~1h)

4. Auto Commit Messages (saved ~30m)

5. Test Generator (saved ~2h)

6. Refactoring Planner (saved ~1h)

7. Performance Audit (saved ~30m)

What I Learned

I Wrote 50 Claude Code Prompts and Used Them for a Week -- Here's What Actually Works

The Methodology

The 7 That Actually Saved Me Hours

1. Code Review Assistant (saved ~3h)

2. Bug Investigator (saved ~2h)

3. Dependency Audit (saved ~1h)

4. Auto Commit Messages (saved ~30m)

5. Test Generator (saved ~2h)

6. Refactoring Planner (saved ~1h)

7. Performance Audit (saved ~30m)

The Ones I Never Touched

What I Learned

Should You Do This?

50 Reusable Claude Code Skills That'll Save You Hours Every Week

1. Git Rescue — /git-rescue

2. Code Review — /code-review

3. Refactor Helper — /refactor-helper

4. Debug Analyzer — /debug-analyzer

5. Test Generator — /test-generator

Building Your Own Skill Library

5 AI Coding Prompts That Changed How I Ship Software

I Just Made 50 Claude Code Prompts Free — Here's Why

The Problem

What I Built

How to Use

1. `git switch` — The Safe Checkout

2. `git log --oneline --graph` — See the Story

3. `git commit --amend` — Edit Without Clutter

4. `git stash push -m "description"` — Named Stashes

5. `git rebase -i` — Clean History Before You Share

6. `git bisect` — Find the Bug Automatically

7. `git worktree` — Work on Two Branches at Once

8. `git diff --cached` — Review Before You Commit

9. `git clean -nd` — Preview Destructive Deletes

10. `git blame --ignore-revs-file` — Skip Formatting Commits

1. Git Rescue — `/git-rescue`

2. Code Review — `/code-review`

3. Refactor Helper — `/refactor-helper`

4. Debug Analyzer — `/debug-analyzer`

5. Test Generator — `/test-generator`