Tag: software-engineering
-
Prompt engineering for code: Few-shot examples that teach taste, not just format
A field-tested take on few-shot examples that teach taste, not just format with Prompt engineering for code: what it rewards, where it breaks, and how to keep the workflow honest.
-
Logging every turn so you can learn from the agent, not just use it
Cline and Roo Code both keep a task history, but it's built for resuming a session, not for studying one. Logging every turn to a plain file turns a stream of one-off interactions into something you can actually search, compare, and learn a codebase's patterns from.
-
The overlooked value of structural search and replace
Structural search and replace matches code by syntax tree, not by text, which makes it exact where an AI rewrite is approximate. For a whole class of mechanical refactors it's the better tool, and most JetBrains users have never opened it.
-
When to reach for Cascade and when to fall back to pure editing
Cascade is genuinely good at multi-file, well-scoped changes. It's a worse tool than your own hands for the single-line fix you already know how to make. The line between the two is narrower than it feels in the moment.
-
Keeping tests running in the background while the agent edits
Cursor's agent mode moves fast enough that a broken test can sit unnoticed for several turns. Running the suite in watch mode alongside it turns a silent failure into an immediate one, and changes how much you trust letting the agent keep going.
-
Keeping answers tight with explicit output contracts
Gemini tends toward comprehensive answers by default, which is great until you're staring at four paragraphs of hedged options for a question with one right answer. An explicit output contract, a stated shape and length before you ask, fixes it structurally instead of fighting it in every prompt.
-
Treating Codex as a junior engineer with an infinite patience budget
Codex does its best work when you brief it the way you'd brief a new engineer: context, constraints, and a clear definition of done, not a one-line prompt. The patience it has for iteration is real. It's still only as good as what you told it about the codebase.
-
Diffing agent output against main before you trust a single file
Claude Code can touch a dozen files in one run and you'll only ever see what it decides to show you in the transcript. A clean working tree before you start is what turns 'trust the summary' into 'read the actual diff.'
-
Leaning on Copilot Edits for multi-file, reviewable diffs instead of raw chat
Copilot Chat is fine for a single function. The moment a change touches more than one file, Copilot Edits produces something reviewable, a proper diff against your working tree, instead of five code blocks you have to reassemble yourself.
-
Caching embeddings locally for a private retrieval layer
Running retrieval against a local Ollama embedding model is easy. Not re-embedding the same document twice, and never letting anything sensitive touch an external API, is the part worth getting right. A local cache and a content hash do most of the work.
-
The honest case for agents that only suggest
Suggest-only agents lost the marketing war years ago. The argument for them isn't caution, it's that the review step is where the value actually lands, and autonomy is what removes it.
-
Why your wiki should probably be an MCP resource, not a tool
Exposing internal documentation over MCP as a search tool means the model guesses when to look. Exposing it as a resource means the human decides. That distinction changes what the integration is good for.