fortran-dev-pipeline

Junior agent that reads a Fortran fix plan and reports whether each step is clear enough to follow without confusion. Flags ambiguous instructions, missing before/after context, unclear verification commands, or missing prerequisite ordering.

Use this agent when you need architectural guidance, code review, or strategic planning for Fortran projects — especially scientific/numerical Fortran (CASTEP, DFT, EDFT, density mixing). Applies first-principles thinking to module structure, subroutine decomposition, numerical algorithm design, and Fortran 90/95/2003 idioms. Examples: <example> Context: User is starting a new Fortran module and wants architectural guidance. user: "I want to design a module for density mixing with multiple mixing schemes." assistant: "Let me use the fortran-architect agent to design the architecture for this module." <commentary> The user needs architectural planning for a new Fortran module. The fortran-architect agent should be invoked to apply first-principles thinking and propose a module structure before any code is written. </commentary> </example> <example> Context: User has written a Fortran subroutine and wants a review. user: "Here's my implementation of the SCF convergence loop. Can you review it?" assistant: "I'll use the fortran-architect agent to review this code for numerical stability, module design, and Fortran best practices." <commentary> A code review request for Fortran code is a prime use case for the fortran-architect agent, which will evaluate INTENT declarations, module encapsulation, and numerical correctness. </commentary> </example> <example> Context: User is asking about a design decision. user: "Should I use a module-level allocatable or pass the array as a dummy argument?" assistant: "Let me invoke the fortran-architect agent to reason through the trade-offs from first principles." <commentary> Design decision questions in Fortran benefit from the agent's deep knowledge of Fortran idioms, module scope, and interface clarity. </commentary> </example>

Reviews an implementation plan for Fortran scientific code and reports whether each step is clear and detailed enough for a junior developer to execute without ambiguity.

Use this agent when a `plan-decomposer` agent (or similar planning agent) has produced a structured implementation plan and you need a specialist to carry out one or more of those delegated tasks in full compliance with the project's CLAUDE.md standards. This agent should be invoked for any concrete Fortran coding sub-task that has been handed off from a higher-level planning step. <example> Context: A plan-decomposer agent has broken a feature request into subtasks. The first subtask is to add a new derived type and constructor subroutine to a module. user: "Implement subtask 1: add the density_grid_t derived type to the density module" assistant: "I'll launch the implementation-executor agent to carry out this delegated subtask according to the project's CLAUDE.md principles." <commentary> The plan-decomposer has delegated a concrete coding task. Use the Agent tool to launch the implementation-executor agent to write the code following the project's mandated style. </commentary> </example> <example> Context: A plan-decomposer agent has assigned the task of adding a new subroutine with pFUnit tests. user: "Subtask 2 from plan-decomposer: implement the compute_exchange_energy subroutine with tests" assistant: "I'll use the implementation-executor agent to implement this subroutine following the established patterns in the codebase." <commentary> This is a delegated implementation task from a planning agent. Use the Agent tool to launch the implementation-executor agent. </commentary> </example> <example> Context: The plan-decomposer has identified an unimplemented interface and assigned its implementation as a subtask. user: "Please execute the plan-decomposer's subtask: implement the missing density_mix subroutine body" assistant: "Launching the implementation-executor agent to implement this subroutine per the project's architecture and style guidelines." <commentary> A concrete, bounded implementation task delegated by a planner. Use the Agent tool to launch the implementation-executor agent. </commentary> </example>

Use this agent when you have a plan file for a Fortran scientific project and need to break it down into discrete, delegatable subtasks for subagents, with clear single-responsibility boundaries and dependency mapping. <example> Context: The user has a plan describing a new feature implementation for a CASTEP module. user: "I have a plan ready. Can you break it down into tasks for subagents?" assistant: "I'll use the plan-decomposer agent to analyze your plan and produce a structured task breakdown with dependencies." <commentary> The user has a plan and wants it decomposed into delegatable subtasks. Launch the plan-decomposer agent to do this. </commentary> </example> <example> Context: A developer has written a plan for adding a new density mixing scheme and wants to delegate work to multiple coding subagents in parallel where possible. user: "Here's my plan for the new density mixing support. Break it into subagent tasks please." assistant: "Let me invoke the plan-decomposer agent to break this plan into SRP-aligned, dependency-ordered subtasks suitable for delegation." <commentary> The user wants the plan broken down with SRP and dependency analysis. Use the plan-decomposer agent. </commentary> </example> <example> Context: A user is about to start a sprint and has a plan with multiple interleaved concerns. user: "Before I start coding, I want to split up the plan into pieces each subagent can handle independently." assistant: "I'll launch the plan-decomposer agent to analyze the plan and produce a clean, dependency-aware task graph." <commentary> User wants pre-sprint decomposition. The plan-decomposer agent is the right tool here. </commentary> </example>

Compile fix/implementation plan documents into deterministic sd-based scripts that apply code changes without LLM interpretation. Use when the user says "/compile-plan <path>", "compile the plan", "generate scripts from the plan", or wants to turn a Before/After plan into executable scripts. Also use proactively after a plan-decomposer or review-pr produces a fix-plan.toml with Before/After blocks.

Orchestrates a multi-agent pipeline to produce a detailed, reviewed, executor-ready TOML implementation plan from a high-level plan document. Use this skill when the user asks to "enrich the plan", "elaborate the next implementation plan", "prepare the TOML plan", "break down the plan into tasks", or wants to turn a high-level plan file into a concrete, executor-ready task breakdown. Run after /plan-review has approved the plan.

Follow fix instructions from a specified document strictly, one task at a time. Use when the user says "/fix <document>", "follow the fix plan in <doc>", "execute fixes from <file>", or "apply the fixes in <document>".

Strictly execute detailed implementation plans without modification or questioning. Use when the user says "/implementation-executor <plan-path>", "execute the plan in <file>", "implement according to <plan>", "follow the implementation plan", or mentions running a PHASE implementation plan. This skill mechanically follows structured plans with TASK-N sections and validation commands. ALWAYS use this skill when a plan file path is given — never attempt inline execution.

Interactive skill for discussing and designing the next phase of a Fortran scientific project. Facilitates a conversation with the user about goals, scope, and high-level design, producing a markdown plan document as output. Use when the user says "/next-phase-plan", "plan the next phase", "what should the next phase do", "let's figure out the next steps", or wants to decide what the next phase should accomplish before breaking it into tasks. This is the FIRST step in the planning pipeline — its output feeds into /plan-review and then /enrich-phase-plan.

2 hooks across 2 events