Menü
Use when creating competitive programming problems with AutoCode MCP tools. Enforces the plugin workflow for problem statements, std/brute solutions, validators, generators, stress tests, final data verification, and Polygon packaging.
Define and enforce project-wide quality standards for agent and skill documents. Use when creating, reviewing, or refactoring files under agents/ and skills/ to keep structure, terminology, and output contracts consistent.
Validate statement samples and sample files for competitive programming problems. Ensures the expected outputs in problem statements match the actual solution output.
Audit std/brute assumptions with MCP evidence, including worst/average complexity risk and stress readiness.
Audit statement, tutorial, and samples for consistency and publication readiness before packaging.
Build multi-profile stress tests from brute complexity and constraints, then execute with traceable evidence.
Verify final tests with hard quality gates: integrity, consistency, validator, limit semantics, and wrong-solution kill.
| name | autocode-workflow |
| description | Use when creating competitive programming problems with AutoCode MCP tools. Enforces the plugin workflow for problem statements, std/brute solutions, validators, generators, stress tests, final data verification, and Polygon packaging. |
| disable-model-invocation | false |
AutoCode is a Claude Code plugin for competitive programming problem setting. It exists because AI-generated problems often fail in subtle ways:
The workflow turns AI output into a gated pipeline. Do not skip gates.
Every workflow checkpoint should use:
decision: go / no_goblocking_issues: unmet gates or risksnext_actions: exact MCP calls needed to proceedIf a gate fails, stop progression and fix first.
Non-interactive problems:
problem_create
-> solution_build(sol)
-> solution_build(brute)
-> solution_analyze / solution_audit_std / solution_audit_brute
-> validator_build(accuracy >= 0.9)
-> generator_build
-> stress_test_run(completed_rounds == total_rounds)
-> checker_build(if non-exact output)
-> problem_validate
-> problem_generate_tests
-> problem_verify_tests(passed)
-> problem_pack_polygon
Interactive problems:
problem_create
-> solution_build(sol)
-> solution_build(brute)
-> solution_analyze / solution_audit_std / solution_audit_brute
-> interactor_build
-> generator_build
-> stress_test_run
-> problem_validate
-> problem_generate_tests
-> problem_verify_tests(passed)
-> problem_pack_polygon
The authoritative implementation is scripts/workflow_guard.py.
| Gate | Requirement |
|---|---|
| Problem setup | problem_create must create directory structure and autocode.json |
| Standard solution | solution_build(solution_type="sol") succeeds |
| Brute solution | solution_build(solution_type="brute") succeeds after sol |
| Complexity audit | solution_analyze, solution_audit_std, and solution_audit_brute reviewed |
| Validator | Non-interactive only: validator_build returns valid accuracy >= 0.9 |
| Interactor | Interactive only: interactor_build is ready |
| Generator | generator_build succeeds after validator/interactor gate |
| Stress | stress_test_run completes all rounds |
| Statement validation | problem_validate passes samples and sample files |
| Final tests | problem_generate_tests creates final tests |
| Test verification | problem_verify_tests passes before packaging |
| Packaging | problem_pack_polygon only after verified tests |
Use these agents when the risk is material:
autocode-idea-auditor: before implementation, especially if the idea has unclear constraints, multiple valid outputs, or interaction.autocode-solution-auditor: after std/brute exist, before relying on stress results or final generation.autocode-package-auditor: before problem_pack_polygon, especially when wrong solutions, checker, interactor, or custom answer extension are involved.problem_createCreates:
autocode.jsonsolutions/files/statements/README.mdstatements/tutorial.mdtests/Do not infer that a problem is ready from file presence alone. Prefer structured tool results and workflow state.
solution_buildBuild sol before brute.
For non-trivial problems, brute must be independent enough to serve as an oracle. If it is the same algorithm as sol, mark this as a risk and run solution_audit_brute.
solution_analyze and audit toolsUse:
solution_analyze to estimate time/space complexity, risk notes, and recommended stress profiles.solution_audit_std to check std complexity and constraint mismatch.solution_audit_brute to check whether brute can support stress testing.Do not accept a claimed complexity without evidence.
validator_buildNon-interactive problems need a validator with evidence. A validator build without effective accuracy is not enough.
Target:
accuracy >= 0.9interactor_buildInteractive problems use interactor_build instead of validator_build and checker_build.
Require an explicit interaction protocol in the statement before final packaging.
generator_buildGenerator should implement semantically distinct strategies:
type=1: tiny / exhaustive / sanity;type=2: random coverage;type=3: boundary and extreme constraints;type=4: targeted worst-case or TLE-inducing patterns.type=4 must not be only "same as type=3 but with max parameters".
stress_test_runUse multiple profiles when possible:
tiny_exhaustiverandom_smalledge_smallProceed only when completed_rounds == total_rounds.
problem_validateValidation failure is a release blocker. Do not generate final tests or package until statement samples and sample files pass.
problem_generate_testsFinal tests should include at least half limit-oriented cases (type=3 + type=4) when candidates are available.
For long-running generation:
resume=true;problem_cleanup_processes only when cleanup is needed.problem_verify_testsMust pass before packaging. Default checks include:
file_countanswer_consistencyvalidatorno_emptylimit_ratiolimit_semanticsUse wrong_solution_kill when wrong solutions are available.
problem_pack_polygonOnly package after problem_verify_tests(passed=true).
Each problem should maintain autocode.json as a readable contract. It should describe:
Use autocode-verify <problem_dir> for quick structural checks.
problem_verify_tests passes.When a step fails:
decision=no_go.blocking_issues.Never patch around a failed gate by skipping it.