Before AI, we wrote code
Before AI, writing software meant writing code.
You opened your editor, created files, wrote functions, fixed bugs, committed changes, and repeated the process. The programmer was responsible for every single line.
Then large language models arrived.
At first, they were just better search engines. You could ask a question, paste an error message, or generate a function. They made developers faster, but the workflow stayed the same.
The developer still wrote the code.
Then something changed.
Instead of asking AI to generate individual snippets, developers began giving it entire tasks.
"Build a login page."
"Refactor this service."
"Add Stripe integration."
Prompt engineering
The prompt became more important than the code itself.
Instead of telling the computer how to do something, developers began describing what they wanted.
But prompts had a problem.
A prompt only knows what you tell it.
If the AI doesn't know your architecture, your coding standards, your APIs, your design system, or the last ten decisions your team made, it has to guess.
Sometimes those guesses are brilliant.
Often they're wrong.
The missing ingredient wasn't a better model.
Context engineering
It was context.
Once developers started feeding AI the entire project—documentation, architecture decisions, coding conventions, design files, previous conversations, database schemas, and existing code—the quality of the output changed dramatically.
The AI stopped acting like an autocomplete tool.
It started acting like an engineer.
Then another shift happened.
Developers realized they no longer needed to execute every task themselves.
Instead of saying:
"Generate this function."
They started saying:
"Implement authentication, run the tests, fix any failures, update the documentation, and commit the changes."
The AI wasn't just generating code anymore.
It was executing workflows.
This is what we now call agentic coding.
An agent doesn't simply answer questions, but rather:
- Plans.
- Reasons.
- Edits multiple files.
- Runs commands.
- Verifies its own work.
- Iterates until the objective is complete.
But even agents have limitations.
No matter how intelligent they are, they eventually lose context. Conversations become too long. Decisions become inconsistent. New information appears after every implementation. Requirements evolve.
The solution isn't a bigger context window.
Harness engineering
The solution is giving the agent a harness.
A harness is everything that allows an AI to act instead of simply respond.
It provides access to your codebase, terminal, browser, documentation, issue tracker, deployment pipeline, testing framework, and external tools.
Without a harness, an AI can only make suggestions.
With a harness, it can implement features, execute commands, validate its own work, fix failures, and continue until the objective is complete.
The harness transforms an LLM into a software engineer.
But even the best harness can't solve one final problem.
Every completed task changes the project itself.
Documentation becomes outdated.
Architecture evolves.
New conventions emerge.
The next task should begin with everything the previous task learned.
Loop engineering
That's where Loop Engineering begins.
Loop Engineering isn't another AI coding tool.
It's a methodology for building software with AI agents.
Every cycle follows the same pattern:
- Prompt — Define the objective.
- Context — Give the agent everything it needs to make informed decisions.
- Harness — Equip the agent with the tools to think, code, test, search, deploy, and validate.
- Loop — Capture everything that changed, update the project's knowledge, and feed it back into the next iteration.
The output of one iteration becomes the context for the next.
Every loop makes the agent smarter about your project.
Every loop reduces repeated mistakes.
Every loop compounds engineering knowledge.
Software development is no longer about writing every line of code yourself.
It's about designing systems where humans provide direction, agents perform execution, and the project continuously learns from every iteration.
That's Loop Engineering. It's not replacing software engineering—it's changing the unit of work from writing code to orchestrating intelligent loops.
