# Create Your First Claude Code Skill in 5 Minutes

> Never blank out in standup meetings again. Learn how to build a custom Claude Code skill that generates instant daily reports of your git activity.

- Canonical: https://suvegasoft.co.uk/blog/create-first-claude-code-skill/
- Published: 2025-11-06T00:00:00.000Z
- Author: Suvegasoft Team
- Tags: Claude Code, AI Automation, Developer Tools, Tutorial

Ever been in a standup meeting when it's your turn to speak and your mind goes completely blank? You know you were productive yesterday, but remembering specific commits, branches, and features on the spot? Nearly impossible.

You end up saying something vague like "worked on bug fixes" while mentally kicking yourself for not checking git beforehand. There's a better way.

## The Standup Memory Problem

As developers, we live in git commits. But our brains? Not so much. By the time standup rolls around, yesterday's work feels like a blur. You could manually run `git log`, parse through commits, and piece together what you did—but who has time for that every morning?

The real problem: **Claude Code can't help you automatically because it lacks two things:**

1. Permission to run git commands
2. Knowledge of the current time (to create unique timestamped reports)

Let's fix both with a custom Skill.

## Enter Claude Code Skills

Skills are like plugins that teach Claude new capabilities. You define what shell commands Claude can run and when to use them. Once created, Claude automatically recognizes when your skill is relevant and uses it—no manual triggering needed.

Here's what we're building: a `git-standup` skill that generates instant daily reports of your git activity, perfectly timestamped.

### Key Benefits

**For Daily Standups:**

- Never blank out when asked what you worked on yesterday
- Get instant recap in 2 seconds vs. 5 minutes of git digging
- Show up prepared and confident every morning
- Perfect memory of commits, branches, and work status
- Smart fallback: automatically handles weekends, holidays, and breaks—no Monday morning surprises

**For Teams & Clients:**

- Timestamped reports mean no file collisions (multiple reports per day if needed)
- Clean audit trail of daily development activity
- Easy to share progress with stakeholders
- Reusable for weekly summaries or time tracking

**For You:**

- One-time 5-minute setup, lifetime value
- Automates a daily repetitive task
- Demonstrates the power of custom AI automation
- Template for building more skills later

## Building the Git Standup Skill

### Step 1: Create the Skill Directory

Skills live in `.claude/skills/[skill-name]/SKILL.md`. The filename must be uppercase.

```bash
mkdir -p .claude/skills/git-standup
touch .claude/skills/git-standup/SKILL.md
```

### Step 2: Define the Skill

Open `.claude/skills/git-standup/SKILL.md` and add this:

````text
---
name: git-standup
description: Generate daily standup reports with git activity from yesterday or recent commits if yesterday is empty, current branch status, and precise timestamps in format YYYY-MM-DD-HH-MM-SS. Create a markdown file with the report.
allowed-tools: Bash(date:*), Bash(git:*), Bash(echo:*), Bash(cat:*), Bash(test:*)
---

# Git Standup Report

Generate a timestamped markdown file with git activity and current branch status.
Smart fallback: if no commits yesterday, shows last 5 commits with dates.

## Commands

1. Generate timestamp for filename:
```bash
date +%Y-%m-%d-%H-%M-%S
```

2. Get commits with smart fallback:
```bash
# Try yesterday's commits first
COMMITS=$(git log --since="yesterday" --pretty=format:"%h - %s" --abbrev-commit)

# If empty, get last 5 commits with relative dates
if [ -z "$COMMITS" ]; then
  git log -5 --pretty=format:"%h - %s (%cr)" --abbrev-commit
else
  echo "$COMMITS"
fi
```

3. Get current branch and status:
```bash
git branch --show-current
git status --short
```

4. Create report file: `standup-report-YYYY-MM-DD-HH-MM-SS.md`

Include in report:
- Report generation timestamp
- Current branch
- Yesterday's commits OR last 5 recent commits (with dates)
- Uncommitted changes (work in progress)
````

### Understanding Each Component

**name**: Simple identifier. Use lowercase with hyphens.

**description**: **This is critical.** Claude reads this to decide when to load your skill. Include specific keywords like "standup", "daily", "yesterday", and the timestamp format. The more descriptive, the better Claude's pattern matching.

**allowed-tools**: Your safety mechanism. `Bash(date:*)` and `Bash(git:*)` mean Claude can only run `date` and `git` commands—nothing else. No accidental `rm -rf` or other dangerous operations. This scoped permission keeps your system secure.

### Step 3: Test the Skill

Launch Claude Code:

```bash
claude
```

Now ask naturally:

```text
Generate my standup report for today's meeting
```

Watch what happens:

1. Claude recognizes "standup report" matches the skill description
2. Loads your skill automatically (no manual command needed)
3. Runs `date +%Y-%m-%d-%H-%M-%S` to get precise timestamp
4. Checks for yesterday's commits—if none, shows your last 5 commits instead (smart fallback!)
5. Runs `git status` to show current work
6. Creates `standup-report-2025-11-06-09-30-45.md` with everything organized

Open the file and you've got your standup talking points ready. No more blanking out.

**The Monday Morning Problem—Solved**: The skill automatically handles weekends and holidays. On Monday, when `--since="yesterday"` would return nothing (because Sunday was your day off), it falls back to showing your last 5 commits with dates like "(3 days ago)". Same for after a vacation—you'll always see what you worked on last, no matter how long the gap.

## Complete Skill Template

Here's the full file for easy copy-paste:

````text
---
name: git-standup
description: Generate daily standup reports with git activity from yesterday or recent commits if yesterday is empty, current branch status, and precise timestamps in format YYYY-MM-DD-HH-MM-SS. Create a markdown file with the report.
allowed-tools: Bash(date:*), Bash(git:*), Bash(echo:*), Bash(cat:*), Bash(test:*)
---

# Git Standup Report

Generate a timestamped markdown file with git activity and current branch status.
Smart fallback: if no commits yesterday, shows last 5 commits with dates.

## Commands

1. Generate timestamp for filename:
```bash
date +%Y-%m-%d-%H-%M-%S
```

2. Get commits with smart fallback:
```bash
# Try yesterday's commits first
COMMITS=$(git log --since="yesterday" --pretty=format:"%h - %s" --abbrev-commit)

# If empty, get last 5 commits with relative dates
if [ -z "$COMMITS" ]; then
  git log -5 --pretty=format:"%h - %s (%cr)" --abbrev-commit
else
  echo "$COMMITS"
fi
```

3. Get current branch and status:
```bash
git branch --show-current
git status --short
```

4. Create report file: `standup-report-YYYY-MM-DD-HH-MM-SS.md`

Include in report:
- Report generation timestamp
- Current branch
- Yesterday's commits OR last 5 recent commits (with dates)
- Uncommitted changes (work in progress)
````

## Skill Creation Checklist

Before deploying any skill, verify:

### File Structure

- [ ] Created `.claude/skills/[skill-name]/` directory
- [ ] Created `SKILL.md` file (must be uppercase)
- [ ] File saved in correct location

### YAML Frontmatter

- [ ] `name` is lowercase and descriptive
- [ ] `description` includes specific keywords, use cases, and timestamp format
- [ ] `allowed-tools` grants only necessary permissions
- [ ] Valid YAML syntax (check for closing `---`)

### Skill Instructions

- [ ] Clear usage examples with bash code blocks
- [ ] Commands are copy-paste ready
- [ ] Common use cases documented
- [ ] Output format explained
- [ ] Instructions concise (1-2 screens max)

### Testing

- [ ] Tested in Claude Code with natural language prompt
- [ ] Skill loads automatically (no manual trigger needed)
- [ ] Commands execute successfully
- [ ] Output file created with correct timestamp
- [ ] No permission errors

## Common Mistakes to Avoid

**Vague descriptions fail:**

```yaml
# Bad - too generic
description: Helps with git reports

# Good - specific keywords and context
description: Generate daily standup reports with git activity from yesterday, current branch status, and precise timestamps in format YYYY-MM-DD-HH-MM-SS
```

**Never grant blanket permissions:**

```yaml
# Dangerous - don't do this
allowed-tools: Bash(*)

# Safe - specific commands only
allowed-tools: Bash(date:*), Bash(git:*)
```

**Wrong filename breaks everything:**

- Must be exactly `SKILL.md` (all uppercase)
- Must be in `.claude/skills/[skill-name]/` directory
- One typo = skill won't load

## Example Prompts That Work

Try these natural phrases with your new skill:

```text
Generate my standup report
```

```text
Show me what I worked on yesterday
```

```text
Create my daily status update for the team
```

```text
What did I commit yesterday?
```

All of these trigger the skill automatically because they match the description keywords.

## More Skill Ideas

Now that you know the pattern, here are other skills to build:

**branch-cleaner**: List and delete merged local branches

```yaml
allowed-tools: Bash(git:*)
description: Clean up local git branches that have been merged to main
```

**test-quick**: Run only tests related to changed files

```yaml
allowed-tools: Bash(npm:*), Bash(git:*)
description: Run tests only for files modified in current branch
```

**changelog-helper**: Generate changelog entries from recent commits

```yaml
allowed-tools: Bash(git:*)
description: Create changelog entries from git commits following conventional commit format
```

**dependency-check**: Show outdated npm packages

```yaml
allowed-tools: Bash(npm:*)
description: List outdated dependencies with current and latest versions
```

## Troubleshooting

**Skill not loading?**

- Verify `SKILL.md` is uppercase in `.claude/skills/git-standup/`
- Include keywords like "standup" or "report" in your prompt
- Restart Claude Code: `Ctrl+C` then `claude`

**Permission errors?**

- Check `allowed-tools` includes the command
- Ensure you're in a git repository: `git status`

**YAML errors?**

- Validate syntax online
- Check closing `---` is present

## What You Just Learned

You now know how to:

- Identify limitations in AI assistants (no time awareness, no shell access)
- Create custom skills that overcome those limitations
- Write proper `SKILL.md` files with YAML frontmatter
- Safely grant shell command permissions with scoped access
- Test skills with natural language prompts
- Build reusable automation that saves time daily

More importantly, you've automated a daily pain point that every developer faces. No more blanking out in standups. No more frantically checking git logs. Just ask Claude, and you're prepared.

## Next Steps

1. Make this part of your morning routine
2. Customize for your workflow (filter by author, add diffs)
3. Share with your team—everyone benefits
4. Build more skills for other repetitive tasks
5. Check the [Claude Code documentation](https://docs.anthropic.com/claude/docs/claude-code) for advanced patterns

The standup memory problem? Solved. Your next repetitive task? Also solvable with a skill.

***

**Built a cool skill?** Share it with us at [Suvegasoft](https://suvegasoft.co.uk)—we'd love to feature your automation ideas.