DEV Community: Gerry Wolfe

The Agentic Manifesto: Why Agile is Breaking in the Age of AI Agents

Gerry Wolfe — Wed, 11 Feb 2026 03:09:38 +0000

Software development has slammed into a "speed of light" wall. We're shackling 2001 processes (dare I say the word, Agile) to 2026 technology (autonomous AI agents).

In 2026, agentic AI is now reality. Anthropic's 2026 Agentic Coding Trends Report shows single agents evolving into coordinated teams, long-running agents building entire systems, and cycle times collapsing from weeks to hours. Gartner predicts 40% of enterprise applications will embed task-specific agents by year's end, up from under 5% last year. McKinsey notes software engineering leading scaled adoption at ~24%. When agents generate features, write tests, review code, debug, and deploy in minutes—often in parallel swarms—the two-week sprint isn't a rhythm; it's a relic. Story points aren't metrics; they're outdated guesses (don't we know it). Detailed Jira tickets aren't guides; they're administrative drag (yes sir, they are).

We are shifting from Waterfall (Big Upfront Design) → Agile (Iterative Human Labor) → Agentic (Architected Intent with Autonomous Execution).

The Agentic Manifesto: 4 Core Values

In this era of agentic autonomy, we have come to value:

Human Intent over exhaustive Technical Requirements.

Humans define vision, goals, and guardrails; agents handle the how.
Continuous Flow over rigid Time-Boxed Sprints.

Work streams in real-time, with agents shipping validated increments the moment they're architecturally sound—not waiting for arbitrary cycles.
Architectural Integrity over sheer Feature Output.

Speed without structure breeds chaos; agents must preserve modularity, security, and maintainability through enforced constraints.
Automated Validation over Manual Estimation.

Agents self-test, self-review, and self-correct via loops; success measures intent accuracy, not velocity or points burned.

1. The Death of the Sprint (and the Birth of Live Continuous Flow)

Sprints suited slow, distractible humans (yes, we're easily distracted by Slack pings, coffee runs even if just to the kitchen, and of course social media) needing predictable windows. Agents don't tire, forget, or demotivate. They execute tirelessly in perception-reasoning-action loops (though high token usage and costs can impose practical limits for us humans that are transferred down to our agent counterparts).

In the Agentic SDLC (or emerging ADLC), work flows continuously. Features deploy as soon as agent swarms validate against architecture, tests pass, and drift is minimal. Waiting for a "Wednesday deployment window" while competitors ship 40x faster? That's self-imposed debt. Anthropic highlights long-running agents building complete systems; multi-agent orchestration is the breakthrough for complex workflows.

2. From "Jira Hell" to "Context Capsules"

Detailed "As a user, I want..." tickets waste human time when agents excel at implementation from high-level prompts. AI needs context, not bureaucracy.

The ticket evolves into a Context Capsule: concise human intent + constraints (e.g., architectural boundaries, security rules, acceptance tests). Agents generate details, iterate via feedback, and log trajectories for traceability. Spending 30 minutes on a ticket an agent completes in 10 seconds? The process is broken.

Emerging tools emphasize intent-based workflows over granular specs. Extensions like ThinkGit — "Git for your thinking" (an extension that I recently published) — take this further by providing version control for AI conversations in Cursor or VS Code. It captures, indexes, and visualizes entire coding sessions, making past prompts, decisions, and evolutions searchable and reusable. This turns ephemeral AI interactions into persistent, increasing knowledge that compounds across projects.

3. The New Stand-up: The "System Pulse"

15-minute sync or even async stand-ups are pre-agentic artifacts. Agents already track commits, logs, trajectories, and drift in real-time.

What if, instead, we had a System Pulse dashboard that surfaces architectural alignment, intent drift, technical debt accumulation, and agent performance? Teams convene not for status, but for high-leverage discussions: Is agent speed introducing subtle brittleness? Does the product's emergent behavior still match business vision? Human oversight scales through intelligent collaboration, per 2026 trends.

4. The Human as "Architect of Intent"

If agents code, review (via peer agents), test, and deploy—what remains for humans?

You are the Architect of Intent:

Developers: Orchestrate agent fleets, enforce modularity, define skills/AGENTS.md and CLAUDE.md files for shared learning, and intervene on edge cases or drift.
Leaders: Align outcomes, not velocity; measure by intent accuracy meaning how precisely the shipped product matches the vision. This requires clarity of vision.
All: Curate guardrails against hallucinations, ensure governance, and build agent-accessible tools.

Success shifts from "how many points burned" (Is there truly any value to this metric?) to sustained architectural health and business alignment.

Agentic Principles (Beyond the 4 Values)

We follow these principles:

Prioritize agent autonomy with human-defined guardrails and observability.
Build agent-first codebases: modular interfaces, fast tests, and MCP or skill-compatible structures for reliable orchestration.
Embrace continuous learning: Maintain shared "mistakes files" and trajectory logs for agent improvement. This aligns with compound engineering (Plan → Work → Review → Compound) from Every, where agents capture structured learnings from each task. Upcoming tools like ThinkGit extend this by versioning full AI conversations in Cursor or VS Code, making it easy to search, visualize, and compound insights across sessions—turning agents into self-improving teammates with institutional memory.
Measure by outcome alignment and system reliability, not proxy metrics. Proxy metrics (story points, velocity) are indirect surrogates; true measures track real business impact (e.g., feature adoption rates, revenue contribution, user satisfaction) and system health (e.g., uptime, architectural drift scores, hallucination/error rates, mean time to recovery).
Integrate multi-agent swarms, worktrees, and parallel agents for complex tasks while scaling human oversight intelligently.
Govern rigorously using security-by-design architecture to mitigate dual-use risks (capabilities that can be repurposed for harm, e.g., code agents generating exploits, malware, or misinformation workflows) and hallucinations. Anthropic's 2026 report emphasizes this as essential for production-scale agentic coding.

Transition Roadmap: From Agile to Agentic

Phase	Legacy Agile Practice	Agentic Shift	Key Enablers / Examples
Planning	Detailed Jira tickets & backlogs	Context Capsules with intent + constraints	High-level prompts, AGENTS.md files, Claude Skills, ThinkGit
Execution	Time-boxed sprints & daily standups	Continuous flow via agent swarms	Multi-agent frameworks (e.g., LangGraph, PydanticAI)
Review & Validate	Manual code reviews & retros	Automated validation + System Pulse	Agentic peer review, trajectory observability
Measurement	Story points & velocity	Intent accuracy & architectural health	Outcome metrics, drift detection

Challenges certainly remain. Over 40% of agentic projects risk cancellation by 2027 without strong governance (Gartner). Hallucinations, coordination failures, and legacy integration demand hybrid approaches—neuro-symbolic agents for verifiability, federated swarms for scale.

Adapt your process to the speed and autonomy of your tools, or watch your process become the biggest source of technical debt.

This is v1 of the Agentic Manifesto. Add comments, experiences, and evolve it. I'll post it as well on my github. The agentic era is here. Let's orchestrate our agents.

Reduce: The Swiss Army Knife of Basic Functional Programming

Gerry Wolfe — Fri, 21 Apr 2023 18:09:50 +0000

Functional programming is a paradigm that emphasizes the use of pure functions, immutable data, and higher-order abstractions. One of the most common and powerful higher-order abstractions in functional programming is the reduce function.

The reduce function takes an iterable (array, list, or other collection) and a function that combines two values, and applies that function to all the elements of the iterable returning a single value (which could be a primitive or an object). The canonical example is summing up an array of numbers.

# Python code
numbers = [1, 2, 3, 4, 5]
sum = reduce(lambda x, y: x + y, numbers)
assert (sum == 15) # True

// Typescript code
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((x, y) => x + y);
assert (sum === 15); // true

The power of the reduce function is its versatility. It can be used to implement many other iterable operations such as map, filter, find, etc.

For example, a filter function is just an implementation of reduce. Let’s see how we can use the reduce function to create our own filter function. A filter function takes an iterable and a predicate (a function that returns true or false), and returns a new object with only the elements that satisfy the predicate. To use the reduce function as a filter function, we need to define a filter function.

# Python code
def filter_by(acc, cur):
  # Check if the current element satisfies the condition using the boolean function
  if condition(cur):
    # If True, append the current element to the accumulator array
    acc.append(cur)

  # Return the accumulator list
  return acc

// Typescript code
function filterBy(acc: any[], cur: any): any[] {
  // Check if the current element satisfies the condition using the boolean function
  if (condition(cur)) {
    // If true, push the current element to the accumulator array
    acc.push(cur);
  }

   // Return the accumulator array
   return acc;
}

Now we can use this function with the reduce function to filter out the even numbers from an array of numbers.

# Python code
numbers = [1, 2, 3, 4, 5]

# Define a boolean function that checks if a number is odd
def condition(x):
  return x % 2 == 1

# Use reduce and filter_by to filter out the even numbers from numbers
odd_numbers = reduce(filter_by, numbers, [])

print(odd_numbers) # [1, 3, 5]

// Typescript code
const numbers = [1, 2, 3, 4, 5];

// Define a boolean function that checks if a number is odd
function condition(x: number): boolean {
  return x % 2 == 1;
}

// Use reduce and filterBy to filter out the even numbers from numbers
const oddNumbers: number[] = numbers.reduce(filterBy, []);

console.log(oddNumbers); // [1,3,5]

Now, let's use reduce to return a Record object. If you have an array of strings that represent colors, you can use a reduce function to count how many times each color appears in the array and return an object with the color names as keys and the counts as values.

# Import reduce from functools module
from functools import reduce

# Define a list of colors
colors = ["red", "blue", "green", "red", "yellow", "blue", "green", "red"]

def get_color_counts(colors):
  # Use reduce on the list
  return reduce(lambda counts, color: 
    # For each color, check if it already exists as a key in the counts dictionary
    counts.update({color: counts.get(color, 0) + 1}) or counts
    # If yes, increment its value by one
    # If no, initialize its value to one
    # Use update and get methods on the dictionary and return the updated counts dictionary
  , colors, {}) # Start with an empty dictionary for the counts

print(get_color_counts(colors)) # {'red': 3, 'blue': 2, 'green': 2, 'yellow': 1}

// Typescript code

const colors: string[] = ["red", "blue", "green", "red", "yellow", "blue", "green", "red"];

function getColorCounts(colors: string[]): Record<string, number> {
  // Use the reduce method on the array
  return colors.reduce((counts: Record<string, number>, color: string) => {
    // For each color, check if it already exists as a key in the counts object
    if (counts[color]) {
      // If yes, increment its value by one
      counts[color] += 1;
    } else {
      // If no, initialize its value to one
      counts[color] = 1;
    }
    // Return the updated counts object
    return counts;
  }, {}); // Start with an empty object for the counts
}

console.log(getColorCounts(colors)); // {red: 3, blue: 2, green: 2, yellow: 1}

Those are just a few examples of the powerful functional nature of a reduce function that allows for concise and expressive transformations of iterable data structures. It can be used to implement many other higher-order functions such as map, filter, and find. The reduce function can help simplify complex computations and make code more elegant and efficient.