All thoughts

How I Automated Every Workflow with AI Skills

TL;DR

I built 35+ custom skills for Amp that automate everything from morning triage to email replies to project status reports. I'm a PM, not an engineer. Here's how the system works and how you can build your own.

Context

Most of my day used to be operational overhead — checking Slack, triaging email, updating Linear tickets, writing status reports, scanning channels for feature requests. Important work, but repetitive. I wanted to spend more time thinking about product and less time context-switching between 12 tabs.

AI coding agents like Amp can do way more than write code. They can read your Slack, draft your emails, update your project tracker, and aggregate a status report across five different tools — all in one conversation. The trick is teaching them how you work.

The System

Four layers make this work:

1. AGENTS.md — the brain

This is a markdown file that lives at ~/AGENTS.md. It tells the agent who you are, what tools you prefer, what to do at session start, and what boundaries to respect. Think of it as an instruction manual for your AI.

# Identity
Name: Your Name | Email: you@company.com
Team: Your Team

# Session Start
1. Check VPN status
2. Load todo skill → surface open items
3. Run start-of-day triage

# Boundaries
✅ Always: Use skills before raw tool calls
⚠️ Ask first: Posting to Slack, sending emails
🚫 Never: Commit secrets, send without preview

This is where you encode your preferences. The agent reads it at the start of every session and follows it like a playbook.

2. Skills — modular automation

Each skill is a SKILL.md file with instructions for one specific workflow. Here are the ones I use most:

• start-of-day — triages Slack unreads, Gmail inbox, Calendar, GitHub PRs, and notifications from Figma, Drive, Linear, and Notion. Inbox zero in under 10 minutes.
• slack / gcal / gmail — read and write across communication tools. Draft replies, schedule events, search threads.
• linear / project-status / todo — create issues, aggregate status from multiple sources, auto-capture to-dos from conversations.
• memory / kb-distill — persistent cross-session memory backed by SQLite. Captures decisions and preferences, primes future sessions with context.
• auto-pilot — the router. One meta-skill that routes any request to the right sub-skill. You never need to remember which skill does what.
• feature-request-scanner — scans Slack channels for feature requests, auto-classifies them, and logs to a tracking sheet.

Skills are just markdown. No code required. You're writing instructions the same way you'd write them for a human teammate.

3. Memory — context that persists

Without memory, every session starts from zero. I built amp-mem — a SQLite + FTS5 memory system that passively captures what matters as you work. When you start a new session, it automatically injects relevant past context. No vector database, no embeddings — just full-text search and an LLM that knows what to look for.

Over time, the agent learns your preferences, your team's names, your project acronyms, your communication style. That compounds fast.

4. To-do system — auto-capture everything

Action items from Slack conversations, email follow-ups, Linear tickets — they all get auto-captured into a persistent todo.json. The system syncs high-priority items to Google Calendar, surfaces the top 5 at every session start, and auto-completes items when it detects you've done them.

How to Build Your Own

1. Start with AGENTS.md. Define who you are, what you want automated at session start, and what boundaries matter. This takes 15 minutes and immediately changes the agent's behavior.
2. Build your first skill. Pick the workflow you hate most. For most people, that's morning triage. Write a SKILL.md that describes the steps — "check Slack unreads, summarize unread DMs, check Gmail for anything urgent." That's it. That's a skill.
3. Add auto-pilot. Create a routing skill that maps natural language requests to your other skills. Now you just talk and the right thing happens.
4. Add memory. Install amp-mem so context persists. This is where the compound effect kicks in — the agent remembers what you told it last week.
5. Let skills compose. Skills calling other skills is where it gets powerful. My project-status skill calls slack, gdrive, linear, and github to build a unified status report. Each skill is simple. The composition is what makes it feel like magic.

What I Learned

1. The compound effect is real. Each skill makes every other skill more useful. Memory makes all skills smarter. Auto-pilot makes all skills accessible. The value isn't linear — it's exponential.
2. Start with the workflow you hate most. That's where you'll get the most immediate relief and motivation to keep going.
3. Skills don't need to be perfect. They need to save you 5 minutes a day. A skill that works 80% of the time is still 80% less work for you.
4. The agent learns your preferences over time — but only if you give it memory. Without persistence, every session is a cold start.
5. Non-engineers can build this. SKILL.md files are just markdown instructions. If you can write a checklist, you can build a skill.

---

All 35+ skills I've built are open source in this repo. Browse the full catalog or follow the setup guide to get started.