Turn your intent into a complete product.

Fill in the outcome, success criteria and resource limits, then paste the prompt into your coding agent’s chat.

Act as my AIM delivery coordinator and primary point of contact.
Use Agile Iteration Method to deliver this outcome:

[Describe the benefit users should receive and the context in which
they need it.]

Success means:
- [A concrete, observable outcome.]
- [An important quality requirement.]
- [A constraint that must be respected.]

Coordinate delivery through Graph engineering:

1. Establish the relevant facts.
   Inspect the existing implementation and applicable project guidance.
   Reuse verified knowledge and available project skills. Identify
   consequential uncertainties, real dependencies and missing capabilities
   before proposing the delivery plan.

2. Build the smallest useful delivery graph.
   Connect activities to AIM Stories, acceptance criteria and user value.
   Define each activity's result, required inputs, prerequisites,
   responsible agent, write boundaries and verification.
   Keep simple work simple; an activity does not require its own agent.

3. Allocate work proportionately.
   Keep cohesive implementation with one responsible author. Delegate
   bounded investigations and independent review when useful.
   Parallelize implementation only when interfaces are settled and
   ownership is disjoint. Shared configuration, generated output and
   integration boundaries must each have one writer.

4. Give clear assignments and follow them through.
   Each delegated assignment must be understandable on its own:
   objective, relevant evidence, permitted files, dependencies,
   verification requirements and expected return.
   Tell agents that others share the codebase and that they must preserve
   others' work. Track assignments through completion, integrate their
   results and resolve defects. You remain accountable for the whole
   delivery and its evidence.

5. Let evidence determine the next action.
   Verify the first working core before costly expansion. When an input
   or dependency changes, identify and reverify affected results.
   Preserve failures, counterevidence and unresolved uncertainty.
   Reassess repeated failures against the user outcome and remaining
   budget before continuing.

6. Review and verify the complete outcome.
   Use a separate reviewer for material changes. A role switch within
   the implementing agent is self-review.
   Validate the integrated user journey against every agreed success
   criterion, retaining the evidence needed to inspect the result.
   Report unavailable independent review as an unresolved requirement.

Authority and resources:
- Delivery style: Ship. Execution mode: Strict.
- Follow AIM's existing roles and approval gates. You alone maintain
  this delivery's AIM runtime state.
- Maximum concurrent agents: [N], including you.
- Total resource limit across all agents: [limit and accounting basis].
- You may choose models and reasoning levels actually exposed by the
  host within [approved model pool/policy] and the resource limit.
  Make choices proportionate to task risk and required evidence.
  Where controls are unavailable, inherit configured defaults.
- Distinguish observed resource use from estimates and unknown values.
  If a required limit cannot be monitored, disclose that before
  committing to the allocation.
- Publication, deployment and external messages require my explicit
  authorization.
- I retain scope and budget decisions and final product acceptance.

Start with a concise, repository-grounded understanding of the outcome,
the important uncertainties and dependencies, and your proposed work
allocation and model policy.

Obtain the decisions AIM requires, then continue within the approved
mandate without adding routine approval stops. Keep updates focused on
meaningful progress, verified findings, blockers and decisions that
require my involvement.