Przejdź do treści
Biblioteka skilli
AI i agenci · Planowanie

agentic-engineering

/agentic-engineering

Projektuje i dekomponuje zadania dla agentów: 15-minutowe jednostki zadań, pętle eval-first i jawne kontrakty wejścia i wyjścia, by agenci działali bez ukrytego stanu.

Licencja
MIT
Ostatnia zmiana repozytorium
25.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 25.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Projektuje i dekomponuje zadania dla agentów: 15-minutowe jednostki zadań, pętle eval-first i jawne kontrakty wejścia i wyjścia, by agenci działali bez ukrytego stanu.

Oryginalny opis (EN)

Use when designing or decomposing a task for agent execution — applies 15-minute task units, eval-first loops, and explicit input/output contracts so agents work reliably without implicit state

Jak działa

  1. Why This is Copilot-Exclusive
  2. When to Use
  3. When NOT to Use
  4. Core Principles
  5. Workflow: Decompose a Task for Agent Dispatch
  6. Task Decomposition Checklist
  7. Anti-Patterns
  8. See Also
Sekcje z nagłówków SKILL.md, w oryginale · 223 linii, 1 342 słów
Podgląd SKILL.md
---
name: agentic-engineering
description: Use when designing or decomposing a task for agent execution — applies 15-minute task units, eval-first loops, and explicit input/output contracts so agents work reliably without implicit state
metadata:
  category: copilot-exclusive
  copilot_feature: "agent task decomposition, eval-first development, multi-agent context contracts"
  origin: ported from affaan-m/everything-claude-code
---

# Agentic Engineering

Design tasks so AI agents can execute them reliably. This is not about *using* Copilot features — it is about **architecting work** so agents succeed on the first attempt, fail loudly when they can't, and hand off cleanly to the next agent.

## Why This is Copilot-Exclusive

The patterns here are specific to Copilot CLI's agent execution model: `task()` dispatch, `read_agent` / `write_agent` lifecycle, SQL session state, and background agents with `mode: "background"`. They don't map directly to interactive coding sessions in other tools.

## When to Use

- Decomposing a large task before dispatching it to an agent or fleet
- Designing a multi-agent workflow where context must transfer between agents
- Debugging why an agent produced incorrect or incomplete output
- Establishing quality standards for a new agentic workflow

## When NOT to Use

| Instead of agentic-engineering | Use |
|-------------------------------|-----|
| You already have tasks and just need to plan them | `plan-mode-mastery` |
| You need to assemble a specialist agent team | `team-planner` |
| You need autonomous execution guardrails | `autopilot-patterns` |

## Core Principles

### 1. The 15-Minute Task Unit

**Rule:** Each agent dispatch should complete in roughly 15 minutes of human-equivalent focused work. In practice: 1–3 files changed, 1 clear outcome, no more than one decision required.

**Why:** Agents fail when context exceeds what fits in a single focused pass. Long tasks require the agent to hold too much state, make too many decisions, and produce outputs that are hard to verify.

**Signs a task is too large:**

- Description contains "and" more than twice
- Requires reading more than 5 files to complete
- Has more than one possible success state
- Cannot be verified by a single test or check

**Signs a task is too small:**

- It is just a file read or a lookup
- A single `edit` call handles it entirely
- No judgment is required

**Decomposition pattern:**

```text
Large task: "Implement user authentication with JWT and refresh tokens"
↓ decompose
T-01: Add User schema + bcrypt password field (DB layer only)
T-02: Implement POST /auth/login endpoint (validate + sign JWT)
T-03: Implement POST /auth/refresh endpoint (validate refresh token)
T-04: Add auth middleware (extract + verify JWT on protected routes)
T-05: Integration tests for T-02, T-03, T-04
```

Each task has one clear output that can be verified independently.

### 2. Eval-First Loop

**Rule:** Define the verification criterion before dispatching the agent, not after.

**Why:** Agents optimized toward a concrete pass/fail signal produce more correct output than agents working toward a vague goal. The verification criterion *is* the specification.

```text
❌ Vague:
"Implement the export function and make sure it works."

✅ Eval-first:
"Implement the export function.
 Verification: `npm test -- export.test.ts` must pass with 0 failures.
 If tests don't exist, write them first (AC: returns valid CSV for valid input,
 returns 422 for invalid date range, returns empty CSV for empty result set)."
```

**Pattern in SQL:**

```sql
INSERT INTO todos (id, title, description) VALUES
  ('impl-export', 'Implement CSV export', 
   'Write src/services/export.ts. Verified by: npm test -- export.test.ts (all pass). If tests absent, write tests first.');
```

### 3. Explicit Input/Output Contracts

**Rule:** Every agent task must have a declared input and a declared output. Never rely on implicit context from the conversation history.

**Why:** Background agents start with no conversation history. Fleet agents run in isolated contexts. Agents that assume they "remember" previous turns produce inconsistent results.

**Input contract** — what the agent needs to start:

- Exact file paths to read
- Specific values to use (not "use the same approach as before")
- SQL queries to run for current state

**Output contract** — what the agent produces:

- Files created or modified (exact paths)
- SQL rows inserted or updated
- Return value if used as a sub-agent

```text
# Weak (implicit):
"Continue implementing the auth system."

# Strong (explicit contract):
Input: src/auth/schema.ts (exists), src/auth/middleware.ts (does not exist yet)
Task: Create src/auth/middleware.ts that reads JWT from Authorization header,
      verifies with the secret in process.env.JWT_SECRET, attaches user to req.user.
Output: src/auth/middleware.ts created; exports verifyToken middleware function.
Verification: npm test -- auth.middleware.test.ts
```

### 4. Prefer Built-In Composition Over Wrapper Skills

**Rule:** When the platform can programmatically call an existing built-in workflow, reuse that
primitive instead of inventing a thin wrapper file around it.

**Why:** Built-ins already carry user expectations, maintenance, and platform-native behavior.
Duplicating them as near-identical local artifacts adds drift without adding capability.

Design handoffs around the real primitive:

```text
Goal: review the finished change before merge

Weak:
"After implementation, use our custom review wrapper and then summarize it."

Stronger:
"After implementation, trigger the platform's built-in review step, then return BLOCKER /
CONCERN / PASS findings plus the next action."
```

When translating upstream patterns, this is often an **adapt** rather than an **adopt** signal.
For example, Claude Code v2.1.108+ can chain built-in commands such as `/review`,
`/security-review`, or `/init` through its `Skill` tool. In Copilot CLI, preserve that
composition intent by calling the existing built-in command explicitly or routing to the closest
existing skill or agent flow rather than creating a redundant new skill.

### 5. Fail Fast, Surface Errors Early

**Rule:** Agents should stop and surface uncertainty rather than guess and continue.

**Why:** An agent that guesses wrong halfway through a task produces partial, hard-to-revert changes. An agent that stops early saves time.

Configure via prompt:

```text
If you are uncertain about the expected behavior, stop and surface the question
as a BLOCKER rather than making an assumption and continuing.
Format: BLOCKER: [question] [what you would assume if forced to continue]
```

### 6. State via SQL, Not Session Memory

**Rule:** Workflow state must live in SQL, not the agent's conversation memory.

**Why:** Agents compact, context windows expire, background agents start fresh. SQL state is persistent, queryable, and explicit.

```sql
-- Track multi-agent workflow state
CREATE TABLE IF NOT EXISTS workflow_state (
    step TEXT PRIMARY KEY,
    status TEXT DEFAULT 'pending',
    output TEXT,
    agent_id TEXT,
    completed_at TEXT
);

-- Agent reads its input from SQL, not conversation history
SELECT output FROM workflow_state WHERE step = 'schema-design' AND status = 'done';
```

## Workflow: Decompose a Task for Agent Dispatch

1. **State the outcome** — one sentence: what exists when done?
2. **Identify the smallest completable unit** — can it be done in 15 min?
3. **Define the verification criterion** — what test/check proves it?
4. **Write the input contract** — what files/values does the agent need?
5. **Write the output contract** — what does the agent produce?
6. **Insert into SQL** — description must include verification criterion

```sql
INSERT INTO todos (id, title, description) VALUES
  ('auth-middleware', 
   'Create auth middleware',
   'Input: src/auth/schema.ts (read). 
    Task: Create src/auth/middleware.ts, export verifyToken function.
    Output: src/auth/middleware.ts created.
    Verification: npm test -- auth.middleware.test.ts (all pass).');
```

## Task Decomposition Checklist

Before dispatching an agent task, confirm:

- [ ] Task completes in ~15 min (1–3 files, 1 outcome)
- [ ] Verification criterion is explicit and runnable
- [ ] Input files/values are named explicitly (no "use the context from before")
- [ ] Output artifacts are specified (exact paths or SQL rows)
- [ ] Failure mode is defined (what to do if verification fails)
- [ ] State needed across agents is in SQL, not assumed from conversation

## Anti-Patterns

| Anti-pattern | Fix |
|-------------|-----|
| "Implement feature X end to end" | Decompose into 5–7 15-minute tasks |
| Verification step is "check if it looks right" | Write a specific test, lint, or build check |
| Agent uses values from "our earlier conversation" | Put values in SQL or the task description explicitly |
| Agent silently recovers from errors | Require BLOCKER output when uncertain |
| 20-task plan dispatched at once | Batch 3–5 tasks, verify between batches |

## See Also

- [plan-mode-mastery](../plan-mode-mastery/SKILL.md) — structuring plans for Copilot execution
- [team-planner](../team-planner/SKILL.md) — dispatching multi-agent specialist teams
- [autopilot-patterns](../autopilot-patterns/SKILL.md) — safe autonomous execution patterns
- [eval-harness](../../testing/eval-harness/SKILL.md) — evaluation framework for LLM pipelines
- [product-capability](../../product/product-capability/SKILL.md) — engineering-ready capability specs with ACs

Wersje

RepozytoriumWynikLicencja
Ta strona · drvoss/everything-copilot-cli100MIT
kannnnna9/ultracode100MIT
affaan-m/ECC100MIT
Mark393295827/third-brain-v7-skills100MIT
affaan-m/ECC90MIT

Migawka bazy z 13.11.2026 · wersja paczki b34bd9e5e758 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90agentic-eval
    Planuje, wdraża lub przegląda prace nad ewaluacją agentową w istniejącym kodzie z kontrolą zgodności, bezpieczeństwa i weryfikacji.
  • 96generate-agentic-loop
    Projektuje lub wdraża ograniczone pętle wykonania agentów z weryfikacją, limitami zasobów i odzyskiwalnym stanem.
  • 100multi-agent-handoff-prompt-protocols
    Projektuje jawne kontrakty przekazania kontekstu i zakończenia zadań między wyspecjalizowanymi agentami AI.
  • 95agentic-tool-design
    Projektuje kontrakty narzędzi MCP, CLI i API dla agentów: granice, schematy, wykrywanie, dowody działania i cykl życia zasobów.
  • 100auditing-agent-architecture
    Pomaga projektować i recenzować systemy agentów opartych na Claude: pętle agentowe i stop_reason, orkiestrację wieloagentową, hooki Agent SDK, dekompozycję zadań i wznawianie sesji, także przy zapętleniach.
  • 98agentic-eval
    Opisuje wzorce ewaluacji i ulepszania wyników agentów AI: pętle samokrytyki i refleksji, potoki evaluator-optimizer, udoskonalanie kodu sterowane testami i oceny rubrykami lub LLM-as-judge.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.