junior-dev-agent

Execute junior-assigned tickets through build and review gates.

5|2|Updated Jun 14, 2026
One-click install
npx skills add https://github.com/dyzsasd/dev-loop --skill junior-dev-agent
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: junior-dev-agent
Source: https://github.com/dyzsasd/dev-loop/tree/main/skills/junior-dev-agent
Command: npx skills add https://github.com/dyzsasd/dev-loop --skill junior-dev-agent

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill automates the implementation tier of a split-dev workflow, ensuring that junior-assigned tickets are built, tested, and shipped according to senior-authored designs without manual intervention.

Core Features & Use Cases

  • Automated Implementation: Pulls and executes junior-assigned Todo tickets, strictly following linked design documentation and acceptance criteria.
  • Gatekeeping & Safety: Enforces build, test, and self-review gates, ensuring that only verified code reaches the review stage.
  • Use Case: When a project is configured for a split-dev model, this agent autonomously picks up implementation tasks, handles git worktree isolation, and manages the hand-off to PM or QA verifiers once the work is ready.

Quick Start

Invoke the junior-dev-agent to begin processing the junior-assigned ticket queue for the current project.

Frequently Asked Questions about junior-dev-agent

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

FAQPage Schema
How do I automate software implementation tasks for junior-assigned tickets?

Automating software implementation tasks is achieved by deploying an autonomous agent that pulls and executes junior-assigned tickets, reading linked design documentation and acceptance criteria to generate code without manual intervention.

What is a split-dev workflow and how does an autonomous agent fit into it?

A split-dev workflow separates senior-authored designs from junior execution. An autonomous agent fits into the implementation tier by picking up assigned tickets, handling code generation, enforcing build and test gates, and managing the hand-off to PM or QA verifiers once the work is ready.

How do I ensure only verified code reaches the review stage in an autonomous dev-loop?

To ensure verified code reaches review, the autonomous dev-loop enforces strict build, test, and self-review gatekeeping mechanisms. It processes implementation tickets through these defined gates, preventing unverified code from advancing.

Do I need a specific CLI tool to manage ticket state transitions automatically?

Yes, managing ticket state transitions automatically requires integration with the dev-loop CLI. The agent relies on this CLI and adherence to defined project-specific dev-split configurations to process tickets and handle hand-offs correctly.

How does an autonomous development agent handle git worktree isolation for implementation tasks?

For implementation tasks, the autonomous development agent handles git worktree isolation by creating separate working directories for each ticket. This ensures that code implementation occurs in an isolated environment before passing through build and review gates for verification.

When should I avoid using an autonomous agent for code implementation?

You should avoid using an autonomous agent for code implementation if your project lacks senior-authored design documentation, defined acceptance criteria, or a configured dev-split environment, as the agent strictly relies on these inputs to execute tickets safely.