Where to go next
You have a harness running, you know what skills and MCP are, and you understand why context management matters. This is what is worth learning next, roughly in order of how quickly it pays back.
Do these first
Write a real instructions file. Most people write three lines in CLAUDE.md and never revisit it. Spend an hour on a good one: the commands, the conventions, the things never to touch. It improves every session afterwards. Start from a template.
Get comfortable with permission settings. Learn what your harness auto-approves and what it asks about, and configure it deliberately. Too restrictive and you approve prompts all day without reading them, which is worse than not having them. Too permissive and something destructive runs unreviewed.
Build the habit of small, reversible steps. Commit before starting. Ask for one change. Review the diff. Run the tests. This sounds slow and is actually faster, because you never spend an afternoon untangling a large wrong change.
Write one skill for something you do repeatedly. The exercise of writing it teaches you more about how agents use instructions than any amount of reading.
Then these
Subagents. Most harnesses can spawn a separate agent with its own context for a defined subtask. The value is context isolation: a research subagent can read twenty files and return a summary, without those twenty files landing in your main window.
Custom commands. Shortcuts for prompts you use often. Small quality of life improvement, quick to set up.
Hooks. Run something automatically at a point in the agent's loop, such as formatting after every edit or blocking a commit if tests fail. This is how you enforce a rule rather than requesting it.
Model selection. Learn which model your harness uses for what, and when a cheaper model is fine. Not every task needs the most capable model, and routing well saves real money.
Worth understanding, less urgent
Evaluation. If you build anything agent based for other people, you will need a way to tell whether a change made it better. Informal testing stops scaling quickly.
Prompt injection and agent security. Becomes important the moment your agent reads untrusted content and can also take real actions. Worth understanding before you connect an agent to production systems.
Building your own MCP server. Easier than it looks, and the right answer when you have an internal system no public server covers.
Safe to ignore for now
Agent frameworks. LangChain, AutoGen, CrewAI and similar are for building agent applications, not for using coding agents. Different problem. Do not start here because a tutorial suggested it.
Fine tuning. Almost never the answer for coding work. Better context and better instructions solve nearly everything people reach for fine tuning to fix.
Multi agent orchestration. Interesting, mostly not yet practical for everyday work. One well configured agent beats five poorly coordinated ones.
Benchmark chasing. Model rankings shift constantly and rarely predict what works on your codebase. Check them when choosing, do not follow them weekly.
The general advice
The field produces more content per week than anyone can read, and most of it is speculation about what might matter. The people getting real value are not the ones tracking every release. They are the ones who set up one tool properly and use it every day.
Pick real work, do it with the agent, and add tooling when you feel a specific friction. That order works. The reverse, building an elaborate setup before doing real work, does not.
Keep going
- Skills, tested and ready to install
- MCP servers, with setup notes and what to watch out for
- Templates for instructions and config files
- Interview questions if you are preparing for agent engineering roles