How Agentic Engineering Turns AI into a Full‑Stack Development Partner

Introduction

Agentic Engineering extends the simple copy‑paste workflow of Vibe Coding into a full‑stack, context‑aware AI‑assistant that can manage the entire software development lifecycle. It treats the developer as a coordinator of AI agents rather than a code writer.

Agentic Spectrum

Router            → LLM decides routing (low autonomy)
State Machine     → Multi‑step routing with loops (medium autonomy)
Autonomous Agent  → Self‑directed execution and learning (high autonomy)

Higher autonomy requires richer tooling, context management, and validation.

Core Components

Commands

Short, slash‑style entry points (e.g., /requirement:new) that delegate work to underlying skills without containing heavy logic.

Skills

Encapsulate domain knowledge and multi‑step workflows. Each skill’s main description ( SKILL.md) is kept under 2 k tokens in the active context; detailed resources are stored in a resources/ folder and loaded on demand.

Agents (Subagents)

Isolated workers that perform large or multi‑turn tasks. They return concise summaries ( <2 k tokens ) to keep the main dialogue lightweight.

Knowledge Management

All project knowledge resides in a plain‑text context/ directory with two sub‑trees:

context/team/ – shared conventions, tooling, and Git policies.

context/project/ – project‑specific architecture, APIs, and design decisions.

Each knowledge item is linked to its source, enabling a three‑state verification model: verified, plausible (needs review), and unknown.

Validation Loops

Outputs pass through progressive checks:

L1 – Syntax and schema validation.

L2 – Domain‑specific rules (e.g., When syntax for rule engines).

L3 – End‑to‑end functional tests, often using Playwright for UI verification.

If a check fails, the system automatically rewrites the prompt and retries, implementing the Ralph Loop pattern.

Ralph Loop (Self‑Iterative Execution)

The same prompt is fed back to the agent after each iteration. A persistent state.json tracks progress; the loop continues until a <promise>…</promise> marker signals completion.

User Prompt → Agent Execution → Stop Hook → Check for <promise>
If not present, rewrite prompt and repeat

Case Study: Automated Activity Configuration

A real‑world workflow creates a marketing activity from a natural‑language request:

Parse the request.

Retrieve templates from context/project/.

Generate a multi‑step plan (S1–S10).

Validate each step with JSON schema, API checks, and Playwright UI tests.

Persist knowledge back to context/ for future reuse.

Key tools used:

AthenaMCP – product and activity management.

GameDebug MCP – rule‑engine configuration.

Playwright with a Whistle proxy to isolate browser sessions from production data.

Team Adoption Strategy

Seed Phase

Show quick wins (e.g., automated code reviews) to spark curiosity, then provide a minimal knowledge base that guides new users through incremental steps.

Growth Phase

Team members clone the repository, which contains the full engineering skeleton (agents, skills, commands). They start by executing /requirement:new on a real task, gradually contributing to context/ as they encounter edge cases.

Embedding Experts

If adoption stalls, embed experienced users to translate the methodology into project‑specific workflows.

Reflections

What worked:

Start with a runnable MVP, then iterate based on concrete problems.

Let each issue drive a concrete improvement (new skill, rule, or tool).

Treat knowledge capture as part of the workflow, not an after‑thought.

Combine result‑first motivation with a step‑by‑step knowledge base.

What didn’t:

Over‑loading context with too many constraints leads to “context rot”.

Lack of quantitative metrics for tool impact makes prioritization hard.

Team members sometimes view agents as tools rather than teammates, missing the “knowledge‑as‑code” mindset.

Advice for newcomers

Fork the repository and delete context/project/ and existing requirements – keep the engineering skeleton.

Run a single real task with /requirement:new to generate the first knowledge entries.

Record any AI mistake in notes.md (one sentence) and later promote it to context/project/ or context/team/.

Share the repository with teammates; they instantly inherit the accumulated knowledge.

Future Directions

Token Consumption as a Productivity Metric

In the AI‑augmented era, token efficiency replaces “developer hours” as the primary productivity indicator. High‑quality context and reusable knowledge dramatically improve output = model × context efficiency.

Enterprise‑Level Tooling

Open‑source agents converge on similar core features, so differentiation will come from:

Native integrations (MCP) with internal platforms such as TAPD, iWiki, QTA, and CI/CD pipelines.

A plugin marketplace that distributes full knowledge‑rich solutions (e.g., a “config‑gen‑engine” skill for activity setup).

Standardized connectors that turn platform APIs into first‑class agent tools, eliminating per‑team configuration overhead.

Multi‑Agent Collaboration

Parallel execution shines for clearly separable tasks (e.g., multi‑checker code review). For tightly coupled stages, a single “person + agent” setup remains more efficient due to lower context‑switch costs. Future work will focus on:

Dynamic task partitioning to feed parallel agents only when the workload is splittable.

Role‑based agents for specialized phases (design, testing) while keeping the main workflow linear.

Overall, Agentic Engineering provides the engineering “infrastructure” that lets AI agents consume tokens efficiently, turning them into a sustainable productivity engine for individuals and teams alike.