Walk a backtracking engine through a pattern with capture groups, predict the span each numbered group records, and trace why a failed branch erases the capture it just wrote.

Run `(a|ab)c` against the string `abc`. The first parentheses grab `a`, the match stalls one character later, and the engine quietly swaps that `a` for `ab` before the pattern finally lands.

Use `\1`, `\2` to match the exact text a group already captured, predict why that re-read forces the backtracking engine class, and decide when a backreference fits versus when structure needs a different tool.

Write `(\w+) \1` and the engine matches `the the` but walks right past `the cat`. The second token is not the pattern `\w+` running again, it is the exact word the first group already grabbed.

Trace why `^(a+)+$` matches instantly but hangs on a near-match, count the equivalent splits the engine retries on failure, and defuse the blowup with an atomic group, a possessive quantifier, or a rewrite.

The regex `^(a+)+$` matches `aaaaaaaaaa` in well under a millisecond, yet hand it `aaaaaaaaaa!`, one character longer and one character wrong, and the same engine on the same machine freezes for seconds, then longer for every `a` you add.