In partnership with
Have you heard about loop engineering?
WTF is loop engineering?: Loop engineering means building a system that prompts the AI agent for you.
It finds the work, gives it to the agent, checks the result, saves what happened, and decides the next step. You still review.
You just stop babysitting every turn.
You ask Codex or Claude Code to fix something.
It does one step. Then it waits. You paste the error.
It tries again. You ask for a plan.
It gives a plan. You say continue.
It edits files. You check the result.
Now you are prompting, checking, correcting, and remembering everything.
That is useful, but it is not really an agent workflow yet.
Addy Osmani (Head at Google Cloud) wrote about something called loop engineering.
The idea is simple:
Instead of prompting the agent again and again, you build a loop that prompts the agent.
The loop can find work, assign it, run checks, save state, and continue later.
I am Alex, welcome to ShortCu8 by Innov8.
Lets Dive Deep 🐰
⭐Today's Shortcut
Prompt engineering is:
You tell the agent what to do next.Loop engineering is:
You design a system that tells the agent what to do next.That sounds small.
It is not.
Because the work changes from:
fix this
now do this
now check this
now continueto:
check what is broken
open a safe workspace
run the agent
verify the result
save what happened
bring me the decisionThat is the shift.
You are trying to build a repeatable loop.
1. A Loop Needs a Trigger
A loop starts when something wakes it up.
That trigger can be simple:
Every morning
Every Friday
When tests fail
When a new issue appears
When a PR is openedExample:
Every morning, check yesterday's failed tests and open issues.
If something looks fixable, write a short plan.
If it is risky, ask me first.In Codex, this can be an Automation.
In Claude Code, this can be /loop, hooks, cron, or GitHub Actions.
But do not start with the tool.
Start with the trigger.
Ask:
What should the agent check again and again?That is your first loop.
2. A Loop Needs a Real Stop Condition
Bad loop:
Fix the bug.Better loop:
Fix the auth bug and stop only when:
- auth tests pass
- lint is clean
- no unrelated files changed
- the summary explains the causeThis is why /goal is interesting.
A goal tells the agent when the work is actually finished.
Not emotionally finished.
Not "looks good" finished.
Finished by a check.
If the stop condition is weak, the agent will stop too early.
So write the finish line clearly.
Bad:
Fix the website.
Good:
Fix the mobile layout and stop only when the page loads without console errors and the header does not overlap on 390px width.The goal is the brake.
Without it, the loop can keep wandering.
3. Parallel Agents Need Separate Rooms
If two agents edit the same repo folder, they can collide.
One changes a file.
Another changes the same file.
Now you are cleaning up the mess.
A worktree solves this.
Think of a worktree as a separate copy of the repo for one task.
One agent can work on the login bug.
Another agent can investigate the dashboard issue.
They do not step on the same files.
Simple rule:
One agent doing one task:
normal workspace is fine.
Multiple agents working at the same time:
use worktrees.This is boring Git plumbing.
But it is what makes parallel agent work less chaotic.
4. Skills Stop You Re-Explaining the Project
If you keep telling the agent the same instruction, turn it into a skill.
A skill can store:
how to run tests
which files matter
what style to follow
what not to touch
how the product works
common mistakes
review rulesWithout skills, every loop starts cold.
The agent guesses your project again.
With skills, the loop starts with known rules.
Example:
Use the project test skill before claiming done.
Use the writing skill before drafting the newsletter.
Use the review skill before opening a PR.This is where loops become useful.
The loop does not need your full explanation every time.
It can pull the right rule at the right step.
5. Connectors Let the Loop Touch Real Work
A loop that only sees files is limited.
Connectors let it work with the places where work actually lives:
GitHub
Linear
Slack
docs
database
staging API
emailExample:
The loop checks GitHub issues.
Finds one with a failing test.
Creates a worktree.
Runs the fix.
Opens a PR.
Links the issue.
Posts the summary.That is different from a chatbot saying:
Here is what I would do.
The loop can actually do parts of the workflow.
Still, be careful.
More connectors means more power.
More power means more ways to break things.
Start with read-only access when possible.
6. Do Not Let the Maker Grade Itself
This is the safety layer.
The agent that writes the fix should not be the only one checking the fix.
It is too easy for the same model to believe its own answer.
Better setup:
Agent 1:
Investigate and fix.
Agent 2:
Review against the goal, tests, and project rules.The verifier asks:
Did this solve the original problem?
Did the test pass?
Did it edit unrelated files?
Did it follow the skill?
Is the summary honest?This is not overkill.
If the loop runs while you are not watching, the checker matters more.
The loop should not just produce work.
It should produce work with evidence.
7. Memory Is the Spine
A loop needs somewhere to write down what happened.
Not inside the chat.
Outside the chat.
That can be:
plan.md
agent-loop.md
GitHub issue
Linear ticket
project memory fileIt should remember:
what was checked
what failed
what was tried
what passed
what is still open
what needs a humanThis is the part beginners skip.
Then tomorrow the agent starts from zero again.
A loop without memory is just a repeated prompt.
A loop with memory can continue.
Beginner Setup
Start with one small loop.
Create a file called:
agent-loop.mdAdd this:
Goal:
Check this project for broken tests or obvious bugs.
Trigger:
Run manually first. Later, run every morning.
Sources:
- recent commits
- test output
- open issues
- README
- project skills
Rules:
- do not edit files first
- write findings as bullets
- mark each finding as fix now / ask human / ignore
- only fix when the cause is clear
- do not touch unrelated files
Verification:
- run the relevant test
- explain what changed
- include the before and after result
- stop if the fix is risky
Memory:
Append every run to this file.Then ask your agent:
Use agent-loop.md.
Run one loop.
Do not edit files until you write the findings first.That is enough for version one.
Now go build something great.
The ShortList
🛠️Cool Tools of the Week:
OpenAI Lockdown Mode: An optional OpenAI security setting to prevent prompt injection and data exfiltration attacks
Manus Shopify Connector: The AI agent app now lets owners build storefronts, manage product catalogs, and generate campaigns using chat.
Dreambeans: A new product from Google Labs that gives users proactive, personalized collections of stories.
📩 Innathe Shortcu8 engane undarunnu 👇️?
We read every reply - just reply to this email and let us know how we can improve !
Appo adutha Shortcu8il kanaam bie…👋
If you read till here, you might find this interesting
#AD1
An engineering fellowship to land your next job
Many engineers feel stalled because the role itself has not evolved. The work looks the same, but the market has moved.
Senior engineering in 2026 demands ownership, faster judgment, and comfort with ambiguity. If your role is not pushing you there, it may be holding you back.
Last cohort, 15 hiring partners sent 31 representatives to evaluate challengers through 246 live interviews. Gauntlet offers a reset. Apply now.
Must be a US citizen to qualify.
#AD2
See Why HubSpot Chose Mintlify for Docs
HubSpot switched to Mintlify and saw 3x faster builds with 50% fewer eng resources. Beautiful, AI-native documentation that scales with your product — no custom infrastructure required.