Office Hours — What former 'must-have' AI agent skills have you deprecated?
A daily developer question about AI/LLMs, answered with a direct, opinionated take.
What former ‘must-have’ AI agent skills have you deprecated?
A year ago, every serious agent builder was obsessed with prompt engineering, tool selection, and memory management. Those skills haven’t become useless, but the problems they were designed to solve have largely evaporated. The frontier has moved, and what felt critical in 2025 is now a solved problem or actively gets in your way.
Prompt Engineering as a Core Skill (It’s Just Noise Now)
In 2025, getting an agent to understand your task required carefully worded instructions, examples, step-by-step reasoning scaffolds, and iterative refinement. You’d spend days tuning a system prompt. That’s gone.
Claude Opus 5 and GPT-5.6 Sol understand complex intent from minimal direction. A sentence describing your task typically works better than a paragraph. The models are reasoning hard enough that explicit chain-of-thought examples often confuse them—the LLM has to unlearn your reasoning pattern to find a better path.
What changed: frontier models now ship with “native” multi-step reasoning built into their weights. Agentic thinking isn’t a prompt trick anymore. You still write instructions, but they should be terse and outcome-focused, not pedagogical.
The graveyard skill: spending 40 hours fine-tuning a system prompt. The current skill: writing a three-sentence specification and letting the model figure out the approach.
Custom Tool Wrapping (Standardization Killed This)
Two years ago, the assumption was that agents would need custom integrations for everything: your internal APIs, databases, custom business logic. Tool-calling was fragmented and vendor-specific.
Today, Claude Code, Cursor Agent, and Devin ship with browser automation, terminal access, and file system operations baked in. GitHub Copilot is multi-model and just works. For 80% of real tasks, the agent can navigate your web UI, run commands, or hit public APIs without custom scaffolding.
The remaining 20% need real integrations, but now you’re just defining OpenAPI specs or MCP (Model Context Protocol) server connections. Both are standardized. You’re not writing bespoke tool adapters per agent anymore.
What you actually do now: expose your critical systems as APIs and let the agent call them directly. The agent’s tool discovery is good enough that you don’t need to hand-rank which tools matter.
Memory Architecture as a Design Problem (Agents Are Stateless by Default)
In early 2025, there was real debate about whether agents needed persistent memory, working memory, episodic buffers, or long-term knowledge graphs. Teams would architect multi-tier memory systems with vector stores, classical databases, and sliding context windows.
That complexity was mostly solving for weak models. Claude Opus 5 and Gemini 3.5 Flash can maintain coherent multi-step reasoning across 1M tokens without explicit memory scaffolding. Claude Code instances running in parallel on macOS and Linux now message each other and share context natively—no custom memory layer required.
Stateless agents work fine now. Each invocation gets context it needs, the model reasons through it, and you move on. For truly long-horizon tasks (days or weeks), you store checkpoints in your own database, not in the agent’s memory design.
The deprecated pattern: building elaborate memory hierarchies. The current pattern: store conversation logs in your database, pass relevant excerpts as context on the next call.
Deterministic State Machines as a Safety Layer (Auto Mode Handles It)
Teams used to build explicit state machines around agents to enforce guardrails: “agent can only take action X after state Y is reached.” This was the safety substitute when autonomous systems were unreliable.
Claude Code Auto Mode now catches 89% of dangerous commands via safety classifiers versus 13.6% for humans—the AI is the primary actor, humans supervise. GPT-5.6 Sol’s computer use achieves 0% prompt injection attack success rate across 129 browser agent test scenarios with proper containment. The scaffolding is in the model now.
You still need approval workflows and audit trails, but not because the agent is incapable—because compliance and visibility matter. The state machine was a proxy for “we don’t trust the model.” You can deprecate it.
Fine-Tuning for Domain-Specific Behavior (Base Models Are Sufficient)
In mid-2025, there was a push to fine-tune models on your codebase, your company’s documentation, your specific domain language. The ROI calculation seemed obvious: better accuracy for the domain, lower token cost.
Databricks benchmarked this ruthlessly and found that open-weight GLM-5.2 matched Claude Opus 4.8 on their million-line codebase at lower cost per task—without any fine-tuning. The frontier models are so general that fine-tuning doesn’t win you much. You’re paying compute cost and latency for marginal gains.
What changed: the baseline is high enough that retrieval-augmented generation (passing context into the prompt) beats fine-tuning for most tasks. Agents can now see your codebase or documentation at inference time without retraining.
Fine-tuning still matters for truly specialized domains (medical imaging, chip design), but not for generic coding or knowledge tasks. Deprecate the fine-tuning pipeline for your standard agent.
Complex Retrieval Orchestration (Single-Pass Retrieval Works)
Teams used to build multi-stage retrieval: first retrieve candidate docs, then re-rank, then retrieve again at higher precision. RAG was treated as a pipeline optimization problem.
Frontier models now reason better through single large context windows. You retrieve aggressively (get 10-20 documents, pass all of them), and the model filters and synthesizes. It’s faster, cheaper on re-ranking infrastructure, and more reliable because you’re not losing relevant context in early filtering stages.
The deprecated pattern: iterative retrieval with ranking stages. The current pattern: retrieve broadly, let the model do the reasoning.
Example: Model Routing by Task Complexity (Just Use Frontier Models)
A year ago, the cost-optimization play was to build routers that classified tasks and sent simple queries to cheaper models. The thesis: 80% of queries don’t need GPT-5.6, so route them to Gemini 3.5 Flash or Claude Sonnet 5.
This still exists in the tooling (Glean’s routing layer, for instance), but the ROI is flatter than it looks. Frontier model pricing has stabilized (GPT-5.6 Sol is $5/$30 per million tokens, same as GPT-5.5, not cheaper). Cheaper tiers do exist: Luna at $0.20/$1.20, Sonnet 5 at the new $2/$10 rate through August. But the savings don’t justify the complexity of routing logic unless you have massive throughput.
For most agents, pick one good model and stick with it. Build your evaluation on that model so you’re not constantly switching.
Constant Prompt Iteration (Write Once, Deploy Anywhere)
Two years ago, shipping a new agent meant designing a prompt, testing it, getting it wrong, iterating, deploying to production, monitoring for drift, iterating again. Prompt tuning was continuous.
Frontier models are stable enough that a well-written initial prompt survives unchanged through dozens of model upgrades. GPT-5.6 Sol’s behavior is backward-compatible with GPT-5.5 code-wise. Claude Opus 5 doesn’t require you to rewrite prompts.
You still monitor for failures, but prompt drift is rare. The “always be prompt engineering” mindset has been replaced by “write a clear spec and check it once per quarter.”
Explicit Error Handling and Retry Logic (Models Are Monotonically Improving)
Three years ago, agents failed often, so teams built elaborate retry strategies: retry with different temperature, retry with a different model, retry with a simplified prompt, degrade gracefully.
Model improvement has been monotonic enough that retry logic is often wasted cycles. If a task fails on Opus 5, degrading to Sonnet 5 rarely helps. If it fails at temperature 0.7, changing temperature doesn’t fix the underlying capability gap.
Current approach: try once with the best model, fail explicitly, and escalate to a human. Retries hide failures and burn tokens for no reason.
Bottom line:
Deprecate prompt engineering as a core skill, fine-tuning for generic tasks, memory architecture design, and routing logic. The frontier models have collapsed these problems into “write clear requirements and call the API.” The real engineering now lives in evaluation frameworks, cost accounting, and compliance auditing—not in tuning prompts or building memory layers. Your agent skills should shift toward observability and system design, not model manipulation.
Question via Hacker News