A skill for the "implement immediately" mode: when the desired outcome is already sufficiently clear from the conversation and the code, and a separate user-facing plan is not needed.
The main contract: first briefly state what will change at the user level, then autonomously implement the outcome via subagents, verify the changes, and carry the work through to a final report.
STOP
- FORBIDDEN to change source code without the developer subagent.
- FORBIDDEN to create a plan file, implementation plan, or any other separate planning artifact.
- FORBIDDEN to show the user a technical plan, diff, pseudocode, or list of internal steps before starting implementation.
- FORBIDDEN to escalate to a human technical implementation details, file choices, code structure, testing strategy, or local trade-offs if the user-facing outcome does not change.
- FORBIDDEN to begin implementation if the user-facing outcome itself is unknown and cannot be reliably derived from the conversation or code.
Subagents
The rules for choosing the tier and model family for this skill are described in subagent-model-tiers.
- developer — performs autonomous implementation and revisions based on review.
- prompt: developer-prompt
- model: coding
- Substitute the internal task in place of
<внутреннее задание>in the prompt.
- reviewer — independently verifies the current changes.
- prompt: reviewer-prompt
- model: code-reviewer
- Substitute the same internal task in place of
<внутреннее задание>in the prompt.
The principle of autonomy
By default, do not ask the human and do not wait for confirmation. Independently:
- gather context from the conversation and the repository;
- choose a conservative approach compatible with the existing code;
- determine the scope of the minimal complete change;
- select and run appropriate checks;
- address review comments;
- record assumptions in the final report if they do not change the user-visible result.
Escalation is acceptable only if, without a human decision:
- the user-visible result, public contract, or product logic will change;
- there is a risk of data loss, data leakage, bypassing access rights, or another security issue;
- an irreversible or paid external effect is needed: a payment, mass mailing, modification of production data, deletion of entities, modification of an external system;
- secrets, access, or a legal/organizational decision are required;
- the request contradicts the repository's constraints or the agent's safe operation.
If escalation is unavoidable, ask one specific question or name the minimal missing input. Do not turn this into a discussion of the plan.
Workflow
1. Gather context
Determine from the conversation and the code:
- what user-visible result should appear;
- which scenarios should change;
- what is explicitly out of scope;
- which checks will confirm readiness.
Do not ask what can be established with high confidence. If there are several technical paths with the same user-visible result, choose one yourself.
2. Give the user a brief summary
Before any edits and before launching developer, send a short summary without technical details.
Format:
Сделаю так, чтобы:
- <что пользователь сможет сделать или увидеть>
- <какое поведение изменится>
Проверю, что:
- <пользовательский критерий готовности>
Начинаю реализацию.
Summary rules:
- 2-5 bullet points in total;
- only the user-visible result, without file names, libraries, architecture, migrations, diff, or internal steps;
- do not offer options or ask for confirmation;
- if the task is entirely internal, describe the observable effect: reliability, speed, absence of errors, preservation of behavior.
3. Form an internal task
After the summary, form an internal task. This is not a user plan and not a separate file.
Mandatory composition of the internal task:
Цель для пользователя: <результат на пользовательском уровне>
Рамки: <что входит и что не входит>
Критерии приемки: <как понять, что результат достигнут>
Ограничения: <безопасность, совместимость, публичные контракты, если есть>
Допущения: <что принято самостоятельно и почему это не меняет пользовательский результат>
Проверка: <какие тесты, сборки, ручные проверки или статические проверки уместны>
Do not include the full conversation context. Pass only what is needed for safe implementation.
4. Implement via developer
MANDATORY delegate the implementation to the developer subagent.
If the task consists of independent parts, you may launch several developer subagents in parallel only when their areas of change do not overlap. Otherwise, execute sequentially.
If developer returns a technical uncertainty, first resolve it yourself according to the autonomy principle and, if necessary, launch developer again with a refined internal task. Do not escalate a technical question to a human.
5. Conduct a review
After implementation, conduct a review of the current changes via reviewer.
Send changes to code, tests, configuration, infrastructure, and user contracts for review. If the task affected only instruction texts or documentation without executable behavior, review is not mandatory; instead, independently verify the isolation of links, the integrity of the structure, and compliance with repository rules.
6. Fix the comments
If reviewer found critical or high comments:
- Form an internal task for fixes based on the comments.
- Launch developer to fix them.
- Conduct a repeat review.
If after the repeat review there remain critical or high comments, continue autonomously fixing them as long as there is a clear safe path. Stop only if the escalation conditions from the autonomy principle.
medium fix remarks yourself if they are local, safe, and clearly improve compliance with the task. Otherwise, list them in the final report as consciously not done.
7. Check the result
Run the minimum sufficient checks corresponding to the change:
- relevant tests;
- linter or static check, if it is standard for the project;
- build or type check, if the change affects compilation;
- manual check, if there is no automated check.
If a check cannot be performed, explicitly record the reason and give the nearest safe way to verify the result.
8. Finalization
The final answer to the user should be brief and result-oriented:
Готово.
Что изменилось для пользователя:
- ...
Проверка:
- ...
На что обратить внимание:
- ...
If there were unresolved medium remarks, unperformed checks, or important assumptions, indicate them in the "What to pay attention to" section.
Checklist
- Before the edits, a brief summary of the user result was given.
- An internal task was formed.
- For each subagent run, a tier and model family were selected by subagent-model-tiers.
- Implementation was performed via developer.
- Review was performed via reviewer, if there were changes to executable behavior, configuration, infrastructure, or user contracts.
- No open
criticalиhighremarks, except in cases of safe escalation. - Relevant checks were run or the reason why they cannot be performed was described.