mentat-implement

Execute mentat plans slice-by-slice with TDD and gate checks.

Updated Jun 5, 2026
One-click install
npx skills add https://github.com/matheushenriquefs/mentat --skill mentat-implement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: mentat-implement
Source: https://github.com/matheushenriquefs/mentat/tree/main/.agents/skills/mentat-implement
Command: npx skills add https://github.com/matheushenriquefs/mentat --skill mentat-implement

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires mentat, and includes scripts (resource) components.

What problem does it solve?

The mentat-implement Skill addresses the challenge of implementing a single mentat plan atomically in the current agent, allowing for Test-Driven Development (TDD), gates, and per-slice commits.

Core Features & Use Cases

  • Atomic Plan Execution: Execute one plan slice-by-slice with TDD and gates.
  • Worktree Isolation: Run each slice in its own worktree and devcontainer for isolation.
  • Serial Merge Queue: Ensure each slice is rebased, re-gated, and fast-forwarded onto a holding branch before merging.
  • Use Case: Ideal for parallel coding agents where each slice represents a portion of a project that can be independently developed and tested.

Quick Start

Execute the 'my-plan' slice with TDD and gates by running: /mentat-implement run --land my-plan

Frequently Asked Questions about mentat-implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I execute a mentat plan atomically with TDD and gate checks?

To execute a mentat plan atomically with Test-Driven Development and gate checks, you can use a dedicated execution skill to run each slice sequentially, ensuring per-slice commits and validation. It processes slices one by one.

What is the best way to isolate parallel coding agents in separate worktrees?

Isolating parallel coding agents in separate worktrees is achieved by executing each plan slice within its own dedicated worktree and devcontainer, ensuring environments remain completely independent during development and testing.

How does a serial merge queue handle isolated worktree branches?

A serial merge queue handles isolated worktree branches by rebasing, re-gating, and fast-forwarding each slice onto a holding branch before merging. This ensures linear history and prevents conflicts between parallel slices.

Do I need mentat orchestration tools to run slice-by-slice TDD workflows?

Yes, you need the mentat dependency and its related orchestration tools installed to run slice-by-slice TDD workflows. The execution relies on mentat to facilitate the underlying atomic plan processing.

Can I run Test-Driven Development gates independently for each code slice?

Yes, you can run Test-Driven Development gates independently for each code slice. The atomic execution process applies TDD and gate checks specifically to each slice before it is committed and merged.

Why use isolated worktrees and devcontainers for parallel plan execution?

Using isolated worktrees and devcontainers for parallel plan execution prevents dependency conflicts and environment pollution. It allows multiple coding agents to develop and test separate slices simultaneously without interference.