The CUJ Engineering Framework: Eliminating Speculative Code Through Autonomous Agent Workflows

A product-driven engineering framework and agentic skill that captures real-world user friction via standardized Mad Libs formulas and autonomously translates them into secure, verified production pull requests.

The Problem Space

Context

Modern software engineering has reached unprecedented development velocity through LLMs and AI coding assistants. However, while generating syntax is now near-instant, the bottleneck has violently shifted upstream to product discovery, user intent capture, and validation.

Engineering teams oscillate between two failure modes:

1. The Speculative PRD Trap: Product managers spend 3–4 weeks drafting 25-page Product Requirement Documents (PRDs) packed with assumptions, edge-case conjecture, and bloated roadmap items that are obsolete before the first sprint concludes.
2. Ungrounded "Vibe Coding": Developers rapidly spin up prototypes based on internal gut feeling or vague feedback, producing technical solutions to problems no real user actually experiences.

The Core Friction

Traditional telemetry and bug trackers (Sentry, Jira, Datadog) capture system crashes and HTTP 500s, but they are fundamentally blind to user intent blockages:

• When a user gets frustrated by an awkward 5-step workflow, high token costs, or lack of cross-device sync, no error is logged.
• The user simply abandons the product, hacks together an inefficient spreadsheet workaround, or cancels their subscription.
• Without a structured mechanism to capture user intent, agents and engineers build the wrong features faster.

The Meta Critical User Journey (CUJ)

Applying the CUJ methodology recursively to product engineering itself reveals the core journey required to bridge user pain and software delivery:

CUJ 1: Autonomous Translation of Friction to Verified Code

• Statement: I want to transform unformatted end-user friction reports into verified production pull requests while avoiding speculative PRDs, hallucinated agent scope creep, and prompt injection vulnerabilities so that engineering teams ship software that measurably eliminates user pain on day one.
• User Scenario: A user hits an annoying friction point in a web app or media tool (e.g., manually cross-referencing TV season release dates). They report it in 15 seconds using a structured Mad Libs prompt. An autonomous agent ingests the report, audits it against security guardrails, creates a sandboxed git branch, writes the feature, tests it against regression suites, and opens a clean pull request linking back to the user's report.

CUJ 2: Frictionless Drop-In Intake Across Any Project

• Statement: I want to install drop-in CUJ capture widgets, GitHub Issue templates, and backend route handlers into any software codebase within 60 seconds while avoiding framework lock-in or heavy telemetry SDK bloat so that my product continuously captures ground-truth user intent.
• User Scenario: A developer initializes a new repository (or adds to an existing service like Plex or an AI search tool). By running a single agent skill (cuj init), the repo receives standardized GitHub Issue forms, an in-app /cuj feedback widget, and an API handler that funnels customer friction directly into agentic triage.

The Ideal Flow

sequenceDiagram
    autonumber
    actor User as End User
    participant App as Web App / /cuj Widget
    participant API as /api/cuj Endpoint
    participant GH as GitHub Issues (cuj-report)
    participant Agent as CDD Autonomous Agent
    participant Sec as Security Evaluator
    participant Git as Git Repo / Branch

    User->>App: Submits Mad Libs ("I want to [X] while avoiding [Y] so that [Z]")
    App->>API: POST /api/cuj (payload)
    API->>GH: Creates Issue with [cuj-report] label
    Agent->>GH: Ingests open CUJ issue
    Agent->>Sec: Runs Machine Review (Prompt injection & Auth checks)
    alt Security Pass & Feasibility >= 80%
        Agent->>Git: Checkouts branch: cuj/issue-42-feature
        Agent->>Git: Writes code, tests, & verifies locally
        Agent->>GH: Opens Draft Pull Request ("Closes #42")
    else Security Flagged
        Agent->>GH: Labels [cuj:security-flagged] + posts threat audit
    end

The CUJ-Driven Development (CDD) Agent Skill

To operationalize this framework across repositories, we formalized CUJ-Driven Development into a reusable agent skill (.agents/skills/cuj-driven-development/).

The Standardized Intake Formula

Every piece of user friction is reduced to the canonical Mad Libs structure:

"I want to [Do X] while avoiding [Friction Y] so that I can [Benefit Z]."

This prevents feature dictation ("Add a drop-down menu here") and forces the focus onto Action, Pain, and Desired Outcome.

Three Execution Modes

Real-World Implementations

We use the CUJ framework across multiple production systems and open-source tools:

1. Plex Media Hub Hub: Installed the .agents/skills/cuj-driven-development/ skill, /api/cuj FastAPI backend, and in-app modal to capture library and watchlist gap friction.
2. Local Meeting Scribe: Solved the multi-meeting speaker diarization gap with 256-dimensional acoustic voiceprints, local privacy, and zero API token costs.
3. American Airlines Household Loyalty: Addressed the single-earner spend bias in co-branded credit card programs.
4. Google Calendar Schedule Helper: Automated zero-latency cross-timezone meeting slot proposal generation.

Try It Live: Submit a CUJ on This Framework

Test our live CUJ intake component directly below. Submissions demonstrate how raw user friction is captured in standardized format: