In this wave of AI programming, concepts are flying everywhere and tools keep getting re-skinned every day, but the underlying stuff isn’t that mystical.
An Agent isn’t magic—at its core, it’s about putting a layer of “structured constraints” (a harness) around an unstable LLM to make the output more controllable. Claude Code and Codex follow this path.
1) See through the LLM first: it’s just guessing the next token
Once you understand this, a lot of “mystical problems” stop being mystical.
However you feed it context, that’s how it will drift; however you steer it, that’s where it will go.
So it’s inevitable that prompting moves from “format worship” toward “natural expression,” but knowing how to ask questions is still a hard skill.
2) Prompting isn’t useless—it should be “less steering, more feedback”
- Don’t stuff a solution in right away—start with the current state and the goal, and let the model give you perspectives;
- Iterate in a problem-driven way: look at the result → point out what’s wrong → rewrite the instruction → validate in a new conversation;
- If your keywords are too rigid, it’s easier to lead the model into a ditch.
In one sentence: control the path less, validate the result more.
3) AGENTS.md matters, but don’t write it as a “complete manual of headbands”
In the community, a lot of ultra-long lists of “must/forbid/principles” are mostly noise.
If you cram in too many constraints, it usually doesn’t become steadier—it becomes duller.
Global instructions should define boundaries and tools, not train style.
4) Don’t get led around by “new-term marketing”
RAG, Context Engineering, MCP, Skills…
A lot of it is essentially old problems in new packaging, or standardizing prompts.
What’s worth chasing isn’t the “terms,” but: can it actually reduce friction and shorten the delivery path?
5) Parallel development has a ceiling: two tasks is most people’s limit
Running three or four Agents looks efficient; in practice it just blows your brain cache.
Notification spam only breaks flow and creates the illusion of “I’m so busy.”
Suggestion: turn off notifications and check progress proactively.
Passive notification response = being ruled by the tempo; proactive task inspection = you control the tempo.
6) Files are memory: move context from your “brain” to the “file system”
CLI Agents rely even more on text-retrieval logic.
To make an Agent stable, you don’t rely on prayer—you rely on project docs that are searchable and reusable.
Files should be written for final execution; don’t stuff in process garbage.
At its core, this is compensating for the model’s innate weaknesses in context and attention.
7) Simplify the workflow: plan first, then code
Your current two-step method is very practical:
- Repeatedly discuss and solidify the plan (PLAN / plans directory)
- Implement the code according to the final plan, and distill implementation docs (docs directory)
Plan files are the anchor; code is the deliverable.
8) Results first: obsess less over an “elegant process,” watch “verifiable delivery” more
Shift from “I hand-hold the Agent to write code” to “I manage the solution and acceptance criteria.”
Don’t nitpick small mistakes in the middle—batch them into the review phase and fix them together.
Code quality isn’t judged by emotions; it’s judged by tests and debuggable structure.
There’s only one core goal: It just works.
9) Mindset upgrade: from executor to manager
Use Codex as an “external brain + rubber duck”: you break down problems, set standards, and make tradeoffs;
it handles execution at scale.
Don’t treat the Agent as a god, and don’t treat it as a toy—it’s an amplifier: it amplifies your judgment, and it also amplifies your chaos.
10) Lessons from bad practices
- Blindly chasing “long-running autonomous operation” doesn’t mean much;
- What’s truly valuable is reducing manual intervention and increasing the probability of stable delivery;
- Copying other people’s Prompt/Skills gets you started fast, but it may not fit your project;
- The most effective growth path: watch the execution process, find the root cause of failures, iterate your own methodology.
