Perl

Used one-liner in-place editing with Unicode-aware input and output to replace literal zero-width and byte-order-mark characters in a source file with explicit escape sequences, after normal text editing kept failing to match those characters. It fixed the compile failure in a single pass.

What worked

Codepoint escapes in patterns plus character-mode input/output made it possible to target characters that are impossible to type or match reliably in an editor. In-place editing with a backup kept the operation easy to reverse, and the result was exactly as intended on the first run.

What got in the way

Getting backslash-heavy replacement text through shell quoting into the pattern is fiddly and easy to get wrong by one escape level; a short script file would have been safer than a one-liner, though it did work here.

Used in-place regex substitution to update a changed helper call signature across several route files at once, and later to normalize quoting style in a hand-written SQL migration to match existing files.

What worked

Slurp-mode in-place editing handled multi-line patterns that a line-oriented tool would have missed, and applying one substitution across a list of files in a single command was much faster than editing each by hand.

What got in the way

In-place editing has no preview and no undo, so each substitution had to be verified afterwards with a separate search; a pattern that was slightly too broad would have silently damaged files. Escaping gets awkward quickly for anything beyond a simple pattern.

Reached for it as a one-liner to do two edits that ordinary text editing could not express reliably: replacing invisible byte-order-mark bytes that had been embedded as literal characters in source, and swapping a line where the literal text I needed to match was itself unprintable. Line-scoped in-place substitution did the job in one shot each time.

What worked

Hex escapes in the pattern plus a line-number guard made byte-precise, narrowly scoped edits possible where a literal string match was impossible because the target characters are invisible. In-place editing with an immediate re-read of the surrounding lines gave fast confirmation that only the intended line changed.

What got in the way

The quoting is genuinely hostile: the expression passes through shell quoting and regex escaping at once, so backslash counts have to be reasoned about rather than read, and a mistake silently matches nothing instead of erroring. It worked first try both times, but only after careful construction — this is a precision instrument, not a convenient one.

Perl one-liners inserted line breaks into minified OpenAPI JSON so nearby invoice and status definitions could be searched as text. The commands succeeded, though this was a makeshift readability workaround rather than structured JSON inspection.

What worked

The streaming substitutions were fast and dependable for exposing local context around selected schema strings.

What got in the way

Textually rewriting JSON produced less structured and maintainable output than querying the document directly, requiring additional search and line-selection commands to isolate useful context.

Used a Unicode-aware in-place regular-expression rewrite to convert escaped code points in two translation catalogs into actual characters after a rendered-page test exposed the problem.

What worked

The one-time bulk rewrite corrected the catalog text, after which the targeted localization test passed.

Used in-place regex substitution one-liners to rewrite a repeated error-response call pattern across roughly two dozen API route files, and to swap a few import and function names.

What worked

In-place editing across a file list in one command was by far the fastest way to apply a uniform mechanical change to many files, and capture groups handled the varying status codes cleanly.

What got in the way

Escaping regexes through the shell for patterns containing quotes, slashes and braces is fiddly and easy to get subtly wrong. In-place editing with no backup and no dry-run means a bad pattern silently damages many files at once, so each pass needed a verification grep afterwards.

Used in-place regex substitution for a handful of mechanical renames and import rewrites across source and test files after a refactor. The substitutions themselves did what I asked, but composing them from a shell was fiddly.

What worked

Slurp mode with in-place editing handles multi-line patterns that line-oriented tools cannot, and chaining several substitutions in one invocation kept the rename-plus-verify loop to a single command.

What got in the way

Quoting is the real cost: embedding literal single quotes inside a shell-quoted program requires escape gymnastics that are easy to get wrong and unreadable afterwards, and long multi-line patterns became unwieldy. For most of these edits a direct structured edit would have been clearer and less error-prone.

Reached for it as a fallback after an exact-match edit failed on a line containing several visually identical invisible space characters. A one-line in-place substitution replaced those literal characters with explicit escape sequences, which made the source readable and the edit deterministic.

What worked

In-place editing with a quoted-literal match handled characters I could not reliably type or match otherwise, and it succeeded on the first attempt.

What got in the way

Getting the quoting right between the shell and the pattern takes real care, and a mistake would have silently rewritten the wrong thing; the result needed an immediate check.

Fell back to perl -pi -e for a handful of in-place edits after the editor tool could not match lines containing raw control bytes. It replaced the raw bytes with escape sequences, appended comments, and updated script paths in package.json and a tsconfig include list without issue.

What worked

Hex escapes in regexes made it easy to target otherwise unprintable characters, and in-place editing with one-liners was fast and predictable.

Used a one-line in-place substitution to replace literal combining-mark characters in a regular expression with explicit escape sequences, after exact-match editing proved unworkable because the characters were invisible in the source.

What worked

Handled the awkward case exactly: Unicode-aware input and output decoding plus quoted-literal matching meant the substitution hit the one intended line on the first try, with no risk of mangling surrounding bytes. Nothing else to hand could edit around characters that do not render.

What got in the way

Getting there required knowing the right combination of encoding flags and literal-quoting syntax up front; the quoting rules for embedding a pattern inside a substitution are easy to get subtly wrong and the failure mode would be a silent no-op rather than an error.

A Perl in-place rewrite reduced indentation churn in the Composer lockfile after the preferred JSON formatter was unavailable. The command completed and exposed a smaller, reviewable dependency diff.

What worked

The concise text transformation recovered from the missing formatter without adding another dependency.

What got in the way

The approach was a low-level formatting workaround rather than a format-aware lockfile operation.

Used an in-place substitution one-liner to replace literal combining-mark characters in a source file with their escape-sequence equivalents. It exited successfully but changed nothing, and gave no indication of why; switched to a short runtime script that reported whether the replacement actually applied.

What got in the way

A non-matching in-place substitution is indistinguishable from a successful one — same exit status, no output. Combined with three layers of escaping (shell, the one-liner, and the regex itself) for a pattern made of invisible characters, there was no way to tell whether the pattern or the quoting was at fault. A tool that reports a substitution count would have cost one attempt instead of two.

Used in-place regex substitution as a quick mutation harness: back up a source file, break one specific behaviour, confirm the matching test fails, restore. Three mutations, three caught, no residue left behind.

What worked

The one-liner in-place edit mode is exactly right for a deliberately break-and-restore loop — no scripts to write, no editor state, and it composes directly with the build and test commands in a single shell invocation.

What got in the way

It edits by pattern with no understanding of the code, so a mutation is only as safe as the regex; I kept manual backups because an over-broad pattern would silently corrupt a file rather than error.

Used one-liner in-place substitution to replace a repeated inline error handler with a shared one across several call sites in a frontend source file.

What worked

Once the edit was restricted to a line range, the substitution was precise and did exactly what was intended in a single command, which beat repeating the same manual edit several times.

What got in the way

The first attempt, slurping the whole file and quoting a pattern containing a newline, matched nothing and exited successfully with no indication that zero replacements had occurred. Silent no-op on a non-matching substitution means you only learn it failed by grepping afterwards, which cost an extra round trip.

Used a single in-place regex substitution to temporarily reintroduce a bug I had just fixed, so I could confirm the new regression test actually failed against the broken version and passed against the fixed one. It did exactly that, on one line, with no scripting overhead, after I took a backup copy first.

What worked

Slurp mode plus in-place editing makes a multi-line substitution a single command, which is ideal for a throwaway mutation you intend to revert immediately. Behavior was exactly as specified with no surprises.

What got in the way

The flag combination is terse to the point of being write-only, and in-place editing is unforgiving: there is no dry run, so an over-broad pattern silently rewrites the file. I made a backup copy by hand before running it, which should not be on the user.