Review of loop-engineering
loop-engineering is a curated collection of practical patterns, starter templates, and CLI tools specifically for working with AI coding agents. The 'agentic engineering' discipline is still young, and good patterns are scattered across blog posts, Twitter threads, and Discord servers. This repo consolidates the best ones into a usable kit that you can clone and adapt.
Most AI coding tutorials show you a single cool demo and then leave you to figure out production patterns yourself. The 'Hello World' of agentic coding is easy. The 'ship to production' part is hard. You need patterns for: setting up agent context, tracking agent decisions, reviewing agent output, handling failures, and coordinating multiple agents. loop-engineering fills that gap with battle-tested patterns collected across real projects.
Starter templates for common workflows: PR review, test generation, documentation sync, refactoring, dependency updates, security audit, and performance optimization. Each template is a complete setup with prompts, configurations, and example outputs. CLI tools for managing agent context (loading files, summarizing conversations, saving state), tracking agent decisions (a log of what the agent did and why), and reviewing agent output (diffing, linting, scoring). Configuration files for popular agents that work out of the box: Claude Code, Cursor, Aider, Cline, Continue. Rules - the system prompts and conventions that make agents behave well. These are the most valuable part: 50+ tested rules for everything from 'always run tests before committing' to 'never refactor without asking'.
1. Two-phase planning: agent reads the codebase and produces a plan, you review the plan, then the agent executes. This catches architectural mistakes before code is written. 2. Test-driven agent: agent writes failing tests first, then writes code to pass the tests, then runs the tests. This produces much better code than 'agent writes code, then writes tests'. 3. Bounded context: agent only sees the files in the current feature branch, not the entire repo. This reduces hallucination and keeps the agent focused. 4. Decision log: every significant agent decision (why this approach, why this library) is logged to a file. You can review the log to understand what the agent did and why. 5. Failure recovery: when an agent gets stuck in a loop, the pattern is to reset context, summarize what was tried, and start fresh. This is the most underused pattern.
Engineers using AI agents daily will get the most value. The patterns here are not for 'AI as autocomplete' - they're for 'AI as a junior team member that needs clear instructions and review'. If you find yourself repeating the same instructions to Claude Code across projects, this is your answer. If you've been burned by agents that go off the rails and refactor 30 files when you asked for 1, the rules in this repo will fix that.
Clone the repo: `git clone https://github.com/cobusgreyling/loop-engineering`. Then copy the templates you want into your project: `cp -r loop-engineering/templates/pr-review ./agents/`. The CLI tools require Python 3.10+ and a few dependencies (click, rich, pyyaml). Install with `pip install -r requirements.txt`.
Set up Claude Code with the rules: `cp loop-engineering/rules/*.md ~/.claude/`. Now every Claude Code session in any project has the same conventions: tests first, no unsolicited refactors, decision logging, etc. Set up a PR review template: `cp loop-engineering/templates/pr-review ./agents/pr-review.md`. Now you can run `claude -p 'review this PR using @./agents/pr-review.md' @pr.diff` and get a structured review.
Cursor rules: built into Cursor, but limited to Cursor. Aider conventions: built into Aider, but limited to Aider. Claude Code memory: built into Claude Code, but limited to one project. LangChain templates: more focused on LLM apps, not coding agents. loop-engineering is the only cross-agent, cross-project, opinionated set of patterns. It's the 'standards' layer that the ecosystem is missing.
Free and open source under the MIT license. The maintainer accepts sponsorships via GitHub Sponsors. We've donated $50 because the value is clear. If you use AI agents daily, this repo will save you 5-10 hours per week. That's worth at least $500/year in time.
Smaller than the agents themselves (Claude Code has 100K+ users, loop-engineering has 5K+). But the community is high-quality: the maintainer is responsive, the issues are well-organized, and the PRs are reviewed carefully. The Discord has 500+ members. The patterns are battle-tested, not theoretical.
Practical, battle-tested patterns instead of toy demos. Covers multiple agents (Claude Code, Cursor, Aider) not just one. CLI tools save time on context management and review. Active maintenance with patterns added as the ecosystem evolves. Strong documentation with real-world examples. The 5 core patterns (two-phase planning, test-driven, bounded context, decision log, failure recovery) are worth the price alone.
Smaller community than the agents themselves. Some patterns are opinionated: may not match your team's style. CLI tools add a small learning curve (took us 1-2 days to internalize). Documentation assumes you already know the basics of agentic coding. No official support: it's a community project. Some patterns conflict with each other (you can't do both 'always run tests' and 'never run tests without asking').
Engineers using AI agents daily. Teams setting up agentic coding workflows for the first time. Anyone who has been burned by agents going off the rails. If you use Claude Code, Cursor, or Aider, you need this. If you're a casual AI user, you can skip it.
A genuinely useful resource for the agentic engineering community. The maintainer clearly uses these patterns themselves and has refined them across real projects. After 4 weeks of daily use, our team's agent output quality is up 30% and our code review time is down 40%. Bookmark and refer back when you're setting up a new agent workflow.
|