title: "From Monolithic Pipelines to Modular Agentic Workflows" date: 2026-08-07 description: "An analysis of modular agentic skills, feature-sliced ticket generation, and the shift toward lightweight semantic guidance in frontier models." tags: [ai, software-engineering, claude-code, agentic-workflows]
The fundamental bottleneck in AI-driven software development is not a lack of generative capability, but a lack of high-fidelity context. When an LLM attempts to build an application, it often operates within a "black box" of probabilistic outputs, leading to inconsistent adherence to typography, color systems, and functional requirements. The core challenge lies in the collection and injection of precise context into the model's prompt window without inducing hallucination or context window exhaustion.
While early agentic frameworks attempted to solve this through monolithic, chained pipelines—such as G-Stack or Sue Howard’s GSD—a new paradigm is emerging. Led by developers like Matt Pocock, the focus has shifted from heavy, rigid "superpower" frameworks toward highly modular, decoupled "skills" that can be triggered non-linearly.
The Failure of Monolithic Agentic Pipelines
Traditional agentic development frameworks often rely on a sequential dependency chain. In these systems, an agent must progress through specific phases: brainstorming, auto-planning, and implementation. This creates a significant architectural fragility. If a failure occurs at step six of a pipeline, the developer is often forced to re-run or manually maneuver the entire preceding sequence.
This "chained" approach treats the development process as a single, unbreakable unit. However, modern software engineering requires agility. The modular skill approach replaces this with an ecosystem of independent, reusable primitives—skills that can be invoked in any order based on the immediate needs of the codebase or the developer's intent.
Contextual Engineering: The grooming Skill
The most critical component of high-accuracy generation is context collection. The grooming skill addresses this by acting as a relentless interviewer, utilizing a decision tree architecture to reach a "shared understanding" between the human and the agent.
The implementation of this skill relies on five core operational rules:
- Relentless Inquiry: The agent must continuously query until consensus is reached.
- Decision Tree Traversal: The agent tackles only one branch of the decision tree at a time (e.g., focusing exclusively on the checkout page before moving to the dashboard) to prevent context fragmentation.
- Sequential Processing: The agent waits for explicit user input before proceeding to the next node in the tree.
- Recommendation-Driven Prompting: To reduce cognitive load, the agent provides specific options rather than open-ended questions.
- Confirmation Gating: No action is taken without an explicit "go" signal from the developer.
By treating context collection as a decision machine, we transform the prompt from a vague instruction into a structured accumulation of architectural requirements.
Engineering Specifications: two-spec and two-tickets
Once consensus is reached via grooming, that data must be persisted. The two-spec skill converts conversational context into a formal Markdown specification. Crucially, this skill enforces a "no code block" policy within the .md spec file.
Including code blocks in a specification is an anti-pattern; if the agent follows outdated or hallucinated snippets from a spec, it creates technical debt. By stripping code from the spec and forcing the agent to cross-reference the actual codebase, we ensure that the implementation remains grounded in the current state of the repository.
Following the spec generation, the two-tickets skill handles task decomposition. Traditional frameworks often group tasks by architectural layer (e.g., all API changes, then all UI changes). This is inefficient for testing and modularity. The Pocock approach advocates for feature-sliced ticket generation. By grouping tickets by functional feature (e.g., "Implement Login Flow" including both the UI and the API logic), developers can achieve end-to-end functionality within a single, testable unit. This promotes a highly modular architecture where features are fully functional upon completion of their specific ticket.
Implementation via TDD and Semantic Code Review
The implement skill leverages Test-Driven Development (TDD) to minimize regression risks. By enforcing a "test-first" workflow—where the agent writes failing tests based on the spec before writing the implementation—the code is shaped by the requirements rather than the model's initial probabilistic guess. This prevents the common issue where an agent writes code that satisfies its own internal logic but fails to meet the external specification.
Post-implementation, the code review skill utilizes a fresh context window and a highly dense semantic checklist. Rather than providing long, wordy instructions, this skill leverages 12 specific keywords derived from Martin Fowler’s Refactoring. By using terms like Shotgun Surgery, Feature Envy, and Data Clumps, the prompt achieves high instruction density with minimal token usage. The model's pre-existing training on these software engineering principles allows it to identify complex architectural smells without needing an explicit, step-by-step explanation of what a "data clump" is.
Token Efficiency: Encapsulation and Deletion Testing
As context windows expand, the risk shifts from "forgetting" to "token exhaustion" through excessive jumping between files. When an agent must traverse dozens of interconnected functions to understand a single feature, the token cost scales linearly with complexity.
To mitigate this, we can implement architectural encapsulation—creating a single entry point or "doorway" for the AI to access complex logic. This reduces the number of file-system hops required to grasp a program's state. Furthermore, we can employ a deletion test strategy: if an agent attempts to remove a function and all existing tests still pass, that function is identified as redundant (dead code) and pruned from the architecture.
The Future Trend: From Guardrails to Guidance
As frontier models like Claude 3.5 Sonnet and future iterations of GPT become more capable, we are observing a significant reduction in system prompt length. Newer models possess higher intrinsic reasoning capabilities, meaning they require fewer "guardrails" and more "guidance."
The trend is moving away from heavy-handed, instruction-laden frameworks (which can actually induce hallucinations by providing too many distractions) toward lightweight, semantic skills. The goal for the next generation of AI engineers should be to write highly pruned, concise prompts that use high-density vocabulary to guide the model's inherent intelligence rather than attempting to override it with rigid, outdated pipelines.