AI-assisted test generation has matured enough that teams are running Behave, Cucumber-JVM 7, and SpecFlow suites where a significant fraction of step definitions were drafted by ChatGPT or Claude. The generation quality is often acceptable. The routing quality under hook context shifts is not. When a @Before hook mutates shared state — a browser profile, a JWT, a database fixture — an AI agent that mapped a step at generation time will silently re-enter the wrong branch at execution time.

The failure mode is subtle: the step matches, the hook fires, but the context the agent assumed during generation no longer holds. You get a green step on a stale session, or a StepNotFound on a step that was perfectly valid 30 seconds earlier in a different scenario. Neither error message points at the hook.

By the end of this article you will know exactly where in the execution lifecycle the misrouting originates, how to reproduce it deterministically, and what structural changes prevent it. The patterns apply to any agent layer — Cursor-generated steps, LLM-backed test runners, or your own orchestration code calling GPT-4o.

What Hook Context Shift Actually Means for an AI Agent

Hook context shift occurs when a @Before or @After hook modifies the execution environment between scenarios in a way that invalidates assumptions baked into a step definition at generation time. In a human-authored suite this is a known risk — senior engineers guard against it with tagged hooks and explicit fixture teardown. An AI agent has no such institutional memory: it maps each step to a definition based on the context snapshot it held during the generation session, not the runtime context it will encounter during execution.

In a modern test architecture — particularly one following a distributed systems test strategy where multiple services share a test harness — hooks frequently mutate auth tokens, database schemas, or network stubs between scenarios. The agent's step registry becomes stale the moment any of those hooks fire. The result is not a crash; it is a silent wrong-path execution that passes CI and ships a defect.

Reproducing and Diagnosing the Misroute

Start by isolating the hook that shifts context. In Cucumber-JVM 7 or Behave, a tagged @Before hook that resets a Playwright browser context is the most common trigger. The agent generated steps assuming a logged-in session; the hook tears it down for the next scenario tagged @guest. The step text is identical — Given the user views the dashboard — but the underlying page object now navigates to a login redirect.

# features/dashboard.feature
@authenticated
Scenario: Analyst views dashboard KPIs
  Given the user views the dashboard
  Then the KPI panel is visible

@guest
Scenario: Guest is redirected to login
  Given the user views the dashboard
  Then the login page is displayed

Both scenarios share the same step text. An AI agent that generated the first scenario's step definition will bind Given the user views the dashboard to a definition that asserts an authenticated page object. When the @guest hook fires and clears the session cookie, the same definition runs, Playwright finds no KPI panel, and the scenario fails — but the failure message says AssertionError: element not found, not "wrong hook context." The root cause is invisible without tracing.

# step_definitions/dashboard_steps.py  (AI-generated, context-unaware)
@given("the user views the dashboard")
def step_view_dashboard(context):
    # Agent assumed authenticated context at generation time
    context.page.goto("/dashboard")
    assert context.page.url == "/dashboard"  # fails silently under @guest hook

The fix is to make the step definition context-aware by reading hook-injected state rather than assuming it. Inject a context.auth_state flag from the hook and branch inside the step — or, better, split into two distinct step definitions with unambiguous text. Custom Cucumber expressions let you encode the auth state directly in the step text, making the routing explicit and agent-proof:

# step_definitions/dashboard_steps.py  (explicit, agent-safe)
@given("{auth_state} user views the dashboard")
def step_view_dashboard(context, auth_state):
    context.page.goto("/dashboard")
    if auth_state == "authenticated":
        assert "/dashboard" in context.page.url
    else:
        assert "/login" in context.page.url

To stress-test an AI agent against hook context shifts — a useful exercise before promoting agent-generated steps to a shared suite — run the suite with randomized scenario ordering. pytest-randomly and Cucumber's --order random flag both work. If run time dropped from 18 minutes to 4 after parallelizing, but flake rate jumped from 2% to 11%, hook context bleed is almost always the cause. Add OpenTelemetry span attributes on each hook invocation (see the OpenTelemetry setup guide for test failures) to correlate hook execution with step misroutes in Grafana.

Where Senior Engineers Still Get Burned

The first mistake is trusting tag-scoped hooks to contain context. A @Before("@authenticated") hook looks safe, but tag inheritance silently widens hook scope when a feature-level tag propagates to every scenario in the file. The AI agent generated steps for individual scenarios; it never saw the feature-level tag. The hook fires on scenarios the agent never intended it to reach, and the misroute is invisible until a scenario fails in an environment where the ordering differs from local runs.

The second mistake is letting the agent own the @After hooks. AI-generated teardown hooks frequently omit conditional cleanup — they reset state unconditionally, which corrupts the context for the next scenario even when that scenario carries a different tag. Human-authored hooks at least carry the mental model of the fixture lifecycle. Agent-authored hooks carry only the context of the single scenario they were generated for. Audit every agent-generated hook before it merges; treat them as untrusted until proven otherwise in a randomized run.

Myths That Make This Problem Worse

Myth 1: If the step text matches, the step is correct. Step text matching is a lexical operation. Context correctness is a runtime property. An AI agent that generates step definitions from a single scenario's context will produce lexically valid, contextually wrong definitions the moment any hook shifts the environment. The match is necessary but not sufficient. Teams that treat a green step registry as a proxy for correct routing will miss this class of defect entirely. The related failure pattern — where AI-generated steps bleed context across scenario boundaries — is covered in detail in the analysis of context bleed in AI-generated BDD steps.

Myth 2: Randomizing scenario order is a stress test for flakiness, not for agents. Randomized ordering is specifically a stress test for hook context assumptions. If your agent-generated suite passes in declaration order but fails randomly, the agent encoded an implicit ordering dependency. This is not a flakiness problem in the traditional sense — it is a context-model problem. Fixing it requires re-generating or refactoring the affected steps with explicit context parameters, not adding retries or increasing timeouts.

Hook context misrouting is the most common silent failure in AI-assisted BDD suites right now, and it compounds as suite size grows. The immediate next step: run your agent-generated suite with --order random ten times and compare pass rates. Any delta above 3% warrants a hook audit. From there, the logical investment is encoding context state explicitly in step text using custom expressions — that alone eliminates the majority of agent misroutes without requiring a full suite rewrite.

Note: This article is for informational purposes only and is not a substitute for professional advice. If you need guidance on specific situations described in this article, consider consulting a qualified professional.