code-execution

Original：🇺🇸 English

Translated

Use when a subtask is ready to implement and has a subtask JSON file with acceptance criteria and deliverables.

1installs

Sourcedarrenhinde/opencode-agents

Added on2026-03-15

NPX Install

npx skill4agent add darrenhinde/opencode-agents code-execution

SKILL.md Content

View Translation Comparison →

Code Execution

Overview

Execute coding subtasks with self-review and quality validation. Runs in isolated coder-agent context with pre-loaded standards.

Announce at start: "I'm using the code-execution skill to implement [subtask title]."

The Process

Step 1: Read Subtask JSON

Load the subtask file specified in $ARGUMENTS:

bash

Read: .tmp/tasks/{feature}/subtask_{seq}.json

Extract:

```
title
```
— What to implement
```
acceptance_criteria
```
— What defines success
```
deliverables
```
— Files/endpoints to create
```
context_files
```
— Standards to apply
```
reference_files
```
— Existing code to study

Step 2: Load Context Files

Read each file in

context_files

:

bash

Read: .opencode/context/core/standards/code-quality.md
Read: .opencode/context/core/standards/security-patterns.md

Understand:

Project coding standards
Naming conventions
Security patterns
Code quality requirements

Step 3: Load Reference Files

Read each file in

reference_files

:

bash

Read: src/middleware/auth.middleware.ts

Study:

Existing patterns
Code structure
Conventions in use

Step 4: Update Status to In Progress

Edit subtask JSON:

json

"status": "in_progress",
"agent_id": "coder-agent",
"started_at": "2026-02-16T00:00:00Z"

Step 5: Implement Deliverables

For each deliverable:

Create or modify the specified file
Follow acceptance criteria EXACTLY
Apply standards from context_files
Use patterns from reference_files
Write clean, modular, functional code

Step 6: Run Self-Review (MANDATORY)

Type & Import Validation:

✅ Function signatures match usage
✅ All imports/exports exist
✅ No missing type annotations
✅ No circular dependencies

Anti-Pattern Scan:

bash

grep "console.log" deliverables  # NO debug statements
grep "TODO\|FIXME" deliverables  # NO unfinished work
grep "api[_-]key\|secret" deliverables  # NO hardcoded secrets

Acceptance Criteria Check:

Re-read
```
acceptance_criteria
```
array
Confirm EACH criterion met
Fix unmet criteria before proceeding

Step 7: Mark Complete

Update subtask status:

bash

bash .opencode/skills/task-management/router.sh complete {feature} {seq} "{summary}"

Verify:

bash

bash .opencode/skills/task-management/router.sh status {feature}

Step 8: Return Report

✅ Subtask {feature}-{seq} COMPLETED

Self-Review: ✅ Types | ✅ Imports | ✅ No debug code | ✅ Criteria met

Deliverables:
- src/auth/jwt.service.ts
- src/auth/jwt.service.test.ts

Summary: JWT service with RS256 signing and 15min token expiry

Error Handling

Missing subtask JSON:

Main agent must create subtask before invoking this skill

Context files not found:

Main agent must run
```
/context-discovery
```
first

Acceptance criteria unmet:

DO NOT mark complete—fix issues first

Red Flags

If you think any of these, STOP and re-read this skill:

"I know the pattern, I don't need to read the context files"
"I'll do the self-review quickly at the end"
"The acceptance criteria are obvious, I don't need to check them"
"I'll mark it done and fix the edge cases later"

Common Rationalizations

Excuse	Reality
"I've seen this pattern before, context files will just confirm what I know"	Projects diverge from common patterns. One wrong assumption = rework. Read the files.
"Self-review is just checking my own work"	Self-review catches type errors, missing imports, and debug code before the main agent sees it.
"The criteria are implied by the task title"	Implied criteria are unverifiable. If it's not written, it's not a gate.
"I'll handle edge cases in a follow-up"	Edge cases left for follow-up become bugs in production. Handle them now.

Remember

Context FIRST, code SECOND—always read context_files before implementing
One subtask at a time—complete fully before moving on
Self-review is MANDATORY—quality gate before marking done
Functional, declarative, modular—clean code patterns only
Return results to main agent—report completion for orchestration

code-execution

NPX Install

Tags

SKILL.md Content

Code Execution

Overview

The Process

Step 1: Read Subtask JSON

Step 2: Load Context Files

Step 3: Load Reference Files

Step 4: Update Status to In Progress

Step 5: Implement Deliverables

Step 6: Run Self-Review (MANDATORY)

Step 7: Mark Complete

Step 8: Return Report

Error Handling

Red Flags

Common Rationalizations

Remember

Related