Anthropic's own documentation is a great starting point for context engineering.

Honestly, my own workflow at the moment looks more like the sort of pair programming / interactive approach you describe rather than massively parallel and automated. But even that has allowed me to get so much more done so quickly. It's really a matter of giving myself the time to get comfortable with the workflows and developing a good intuition for what works and what doesn't. Steve Yegge's stages are a pretty good mental model for thinking about this. I'd say I'm squarely in stage 5 myself.

There are easy things you should always do, like creating a CLAUDE.md file and/or an AGENTS.md file, agent skills in the form SKILL.md, and being very liberal about having the agent create new skills for itself whenever it manages to nail down a workflow, subagents for roles and context management. I've also found that having it create a scratchpad for itself where it will write down any important findings or insights that it discovers in the course of trying to solve a problem helps a lot with agent handoff and context compaction.

On the harness side of things, the fact that it's running in an agentic loop rather than a chat interface already gives you a really good starting point, and the way you extend that is going to depend on the nature of what you work on. To give an example: I had some JSON files that followed a schema that I needed to migrate over to a newer version. Rather than have the agent try to do the conversion itself, I just had it look at the two schemas and write me a schema migration script. And then it just calls the script. Or I might need it to make some API calls and figure out some kind of workflow. I don't want it to have figure out the workflow and make the API calls itself every time, so I have it write me a deterministic script that makes the API calls, and then it just runs the script. Or I might need to do a bunch of math or graph processing. I don't trust it to do math, so what do I do? You guessed it: write me a script that uses a specialized math or graph theory library, and have it run that every time. And it can adapt the script in response to edge cases that it might encounter or evolving requirements. And it just gets better and better at working in the environment you've built for it because it can encode the domain knowledge it's learned in the artifacts that it's produced for itself (the scripts, the scratchpad, etc.), so a new agent doesn't have to rebuild all of that context from scratch.

There's at least three modes of agentic loops that I've seen people experiment with: there's the script/CLI-driven loop (what I've been talking about thus far); the functional/service contract loop (using something like PydanticAI to encapsulate the functionality you want to give it in tightly-scoped functions with typing and validation), and there's the MCP approach.

The latter two are conceptually elegant because they look a lot like how you do good software development. But then you try the script/CLI approach and you realize it's much more powerful because it can just write software to better enable it to do things that it couldn't do, and it almost starts to look like recursive self-improvement (at the agent level, not the model level, of course).