implement-step

Execute deterministic teleoperator loops via the track-state CLI for software development tracks.

Updated May 7, 2026
One-click install
npx skills add https://github.com/AtaraxiaEpiphany/conductor --skill implement-step-ataraxiaepiphany
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implement-step
Source: https://github.com/AtaraxiaEpiphany/conductor/tree/main/skills/implement-step
Command: npx skills add https://github.com/AtaraxiaEpiphany/conductor --skill implement-step-ataraxiaepiphany

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This skill solves the issue of inconsistent or overly verbose agent behavior during software implementation by providing a strict, code-driven teleoperator loop that enforces state machine discipline.

Core Features & Use Cases

  • State Machine Enforcement: Executes track-state steps to ensure atomic transitions and strict adherence to the project's lifecycle.
  • Subagent Orchestration: Dispatches specialized agents for specific tasks like testing, analysis, and refutation while maintaining a rigid result-block protocol.
  • Use Case: Use this skill when you need to perform a spike or implement a specific track with a small-window model, ensuring that every action is verified against the track-state spine.

Quick Start

Invoke the implement-step skill by providing the name of the track you wish to execute.

Frequently Asked Questions about implement-step

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

FAQPage Schema
How do I enforce a strict state machine for software development track execution?

You enforce state machine discipline for track execution by running a deterministic teleoperator loop that interfaces with the track-state CLI to manage atomic phase transitions. This prevents inconsistent agent behavior by verifying every action against the project's lifecycle.

What is the best way to orchestrate subagents for TDD automation without verbose agent behavior?

Orchestrating subagents for TDD automation requires a rigid result-block protocol that dispatches specialized agents for testing and analysis. A conductor environment maintains state consistency by managing subagent dispatching while preventing overly verbose responses.

Do I need Python 3 and the Conductor plugin to use a teleoperator loop for track-state?

Yes, a teleoperator loop requires Python 3 and the Conductor plugin environment to maintain state consistency and workflow discipline. These dependencies are mandatory for executing track-state CLI commands and managing deterministic phase verification.

How do I implement a specific track with a small-window model while ensuring actions are verified?

You implement a track with a small-window model by invoking a teleoperator that dispatches subagents and enforces phase verification. Every action is strictly verified against the track-state spine to maintain deterministic execution and workflow discipline.

When should I not use a deterministic teleoperator loop for software implementation?

You should not use a deterministic teleoperator loop if your project lacks a track-state CLI or does not require strict state machine enforcement. It is designed for tracks needing rigid atomic transitions and subagent orchestration, not for flexible or ad-hoc coding tasks.

Can I use subagent orchestration for failure analysis during phase verification?

Yes, subagent orchestration handles failure analysis by dispatching specialized agents to analyze failures within the strict state machine framework. The teleoperator loop manages this dispatching while maintaining the required result-block protocol.