suchuanyi

If you're using BMAD (Breakthrough Method for Agentic AI Development), you know the pain: every story requires running through create → develop → test → review → fix → update status. For an Epic with 8 stories, that's potentially 40+ manual commands.

I wrapped this entire workflow into Claude Code Skills. Now one command delivers a complete Epic:

/bmad-epic-worktree

For a single story: /bmad-story-deliver

It handles: - Development implementation - QA automated testing - Code review - Auto-fix HIGH/MEDIUM issues - Update status to Done

Three modes available: 1. Fast mode - Quick iteration, tests run but failures don't block 2. Safe mode - Git worktree isolation, won't merge if tests fail 3. Batch mode - Deliver entire Epic with one command (my favorite)

For company projects, I recommend splitting the flow: manually review the story design first (since that determines what to build), then let automation handle the rest.

The core idea: automate the repetitive stuff, but keep human oversight where it matters.

I built a virtual pet that lives in your Claude Code status line and reflects your AI usage patterns.

  The pet's energy decays over time (~3 days from full to death), and you feed
  it by consuming tokens through Claude Code. As energy drops, the pet shows
  different expressions: (^_^) when happy, (o_o) when hungry, (u_u) when sick,
  and (x_x) when dead.

  What makes it interesting is the death mechanic - when your pet dies (energy
  hits 0), all your statistics reset to zero and you start completely fresh.
  It's like a gentle reminder of the ephemeral nature of our AI interactions.

  Setup is simple: just add `"command": "npx ccpet@latest"` to your Claude Code
  status line config. The pet persists across sessions and gives you a live view
   of your current session stats (input/output/cached tokens).

  It's written in TypeScript, fully tested, and published to npm. I found it
  surprisingly motivating to keep my "pet" alive while coding!

I built ccshell to solve the constant problem of forgetting shell command syntax. Instead of searching Stack Overflow for "how to batch rename files with timestamps" or "compress videos while maintaining quality", you just describe what you want:

  • ccshell "find all files larger than 100MB"
  • ccshell "convert all HEIC photos to JPEG"
  • ccshell "download all images from a webpage"

  It uses Claude Code CLI with intelligent prompt engineering to:
  - Automatically detect and install the right tools (via brew, etc.)
  - Show real-time progress and execution status
  - Handle complex, long-running tasks
  - Work safely with file operations

  Try it immediately without installation:
  npx ccshell "list all files in the current directory"

  Built for macOS initially, but the approach could work cross-platform. The
  three-tier strategy (local commands → tool installation → custom scripts)
  makes it surprisingly reliable.

  Would love feedback from the community on making shell interfaces more
  accessible!

If you’re on a Pro account, it’s common to hit the usage limit in the middle of a long-running task. Claude Code will tell you you’re out of quota, and the reset time might be something like 3 AM.

If you’re asleep by then, you miss the chance to resume right when it resets. The script is just a workaround to automatically pick up where you left off as soon as the quota is restored.

Fair concern — but I’d argue it’s not really ‘vibe-coding’ the tests. With Playwright MCP, the AI uses structural page data and ref_ids captured at runtime, which leads to highly stable and reproducible interactions. It’s not guessing — it’s anchored in what the browser sees.

In practice, the tests it generates are actually easier to reason about than a lot of hand-written Playwright code I’ve seen in the wild. And for scenarios like acceptance testing or rapid iteration, this approach speeds things up without sacrificing much in terms of clarity or stability.

I get where you’re coming from — a lot of LLM-based UI testing tools today do feel flaky or unpredictable. But Playwright MCP works quite differently from what you’re describing. It doesn’t rely on AI guessing or using fragile selectors.

When the page loads, Playwright MCP dynamically assigns a ref_id to every element in the DOM, and the AI simply uses those IDs to interact with the UI. This makes execution extremely stable and repeatable — no need to ‘prompt engineer’ your way past random click errors.

In fact, with a properly set up environment, test steps written in natural language can be executed directly and reliably without writing or debugging traditional code.