Bad code is the most expensive it's ever been.

While agentic coding is powerful, it introduces new engineering challenges around control, reliability, and maintainability.

The goal is not to make agents write more code; it is to make them produce code that stays easy to change.

So why does this matter?

Agentic engineering starts from a simple observation: large language models are no longer just autocomplete systems. In many workflows, they behave more like interpreters. The "program" is not only code. It is the whole input you give the model:

• instructions
• constraints
• files, examples
• tools
• state
• environment

In that sense, the context window becomes the new execution surface.

In an agentic system, some behavior is still encoded in code, but a meaningful part of the system is produced at runtime from language, context, and tool use. The practical question becomes "what capability do we give the agent, and how do we shape its judgment?”

These systems are stochastic. They can be useful, capable, and often impressive, but they are not inherently verifiable in the way ordinary programs are. The core research problem in this paradigm is verifiability.

This is why prompting alone is not enough. You need:

• orchestration
• evaluation
• interfaces
• tool design
• environment control
• testable boundaries
• reviewable outputs

Hence, setup matters a lot. The problem this guide is trying to address is how we can design reliable systems with non-deterministic intelligence.

Software 3.0

What’s described above is sometimes described as Software 3.0: software is increasingly specified in natural language and executed through models. The agent carries packaged intelligence and adapts its actions to the local environment. Instead of building a fixed application for every narrow workflow, you can often describe the task and get a bespoke solution for that situation.

Here is what the division of tasks is likely to look like in Software 3.0:

1. Deterministic (old school) software serves as infrastructure, boundary, and tool.

   This is so that we can manage persistence, permissions, computation, integration, testing, and enforcement.

2. The neural network handles interpretation, synthesis, and adaptation.

This is why agentic engineering is not mainly about making software generation faster. Some of the value is speed, but the deeper change is that new kinds of systems become possible. Agents can inspect a codebase, form a plan, use tools, recover from intermediate failures, and adapt their approach to the environment. That is qualitatively different from ordinary automation.

Here are other things to add on into this guide to take this to the next level:

• Use image generation to have Codex create an image before doing the generation. This allows us it to do the UI/UX generation based on the image so it aligns better.
• Figure out how to code faster because that is the main bottleneck at this point.
• Figma MCP server to visualise code
• Add the https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md grill-me skill
• Use a Skill to go from PRD (Product Requirement Document) to Issues. The main idea behind this step is to break up the task into thin vertical slices and set up dependencies between them. Use an issue tracker such as Linear or Beads.
• Record videos of the feature working from the browser use tool
• Set up logging to receive a history of errors and avoid the need to copy paste error messages
• Use an MCP server to access documentation so that agent can actually reference module specs. Tools include DeepWiki, ZReader and Better Context.
• Compact the memory files once they exceed a given limit by creating hierarchy and pushing submodules lower into the repo

Coding tools

Kiro

Here, I go through Hacks & Tips for using Kiro:

Productivity:

• Type your next message while I'm still working — messages queue automatically (Activity Tray: Ctrl+X)
• Ctrl+R for reverse history search across sessions
• @ in input for async file search with autocomplete
• /spawn to run parallel agent sessions

Get better results:

• Create custom agents (.kiro/agents/my-agent.json) with focused prompts, restricted tools, and pre-loaded context files
• Use resources in agent config to auto-load relevant files into context
• Use skill:// resources for on-demand loading of large reference docs
• Use hooks (agentSpawn, userPromptSubmit) to inject dynamic context (git status, env info)
• Index your docs with knowledge bases so I can search them semantically: ask me to "add ./docs to knowledge"

Trust & speed:

• -trust-all-tools or --trust-tools=fs_read,fs_write,execute_bash to skip approval prompts
• Set allowedTools in agent config for permanent auto-approval
• chat.enableThinking true for complex reasoning tasks

Automation:

• Headless mode: kiro-cli chat --no-interactive --trust-all-tools "run tests and fix failures"
• Save/load sessions: /chat save and /chat load for resumable work
• -resume to pick up where you left off

Code intelligence:

• Run /code init once per project to enable LSP features
• Use /code overview to quickly understand unfamiliar codebases
• AST pattern search/rewrite for structural refactoring across files