What if your AI coding agent could find a bug, fix it, test the solution, and prepare a pull request while you're sleeping? You can already build this with Claude Code, Codex, and GitHub Actions. But there's a better approach than simply giving an AI agent a task and hoping it finishes correctly. Build a system that makes AI prove its work. This is where autonomous AI agents, feedback loops, and verification-driven development become genuinely useful. Here's how I'd build it. 1. START WITH ONE REPEATABLE PROBLEM Imagine you're maintaining a website or application on GitHub. A developer pushes an update. Suddenly, a feature stops working. GitHub Actions detects a failing test. Normally, someone needs to investigate the error, identify the cause, write a correction, run the tests, and submit the fix. Now imagine an AI coding agent handling much of that process automatically. The workflow becomes: Code change → Test failure → AI investigation → Proposed fix → Independent verification → Pull request → Human approval. The important part isn't automation alone. It's making every proposed change pass a predefined verification process. 2. USE THE RIGHT TOOLS You don't need an expensive multi-agent framework. A practical setup can use: Claude Code or Codex for investigating and modifying code. GitHub Actions for triggering workflows and running tests. Git branches or worktrees for isolating experimental changes. A test suite for evaluating proposed fixes. GitHub pull requests for reviewing and approving results. And there's a newer option worth exploring. GitHub Agentic Workflows allows developers to define AI-powered repository automations using Markdown instructions and workflow configuration. It supports multiple coding-agent engines, including Claude, Codex, Gemini, and GitHub Copilot. You can install its CLI extension with: gh extension install github/gh-aw Then initialize the repository: gh aw init The system can compile supported workflow definitions into GitHub Actions workflows. This is particularly interesting because you can define permitted outputs, such as creating an issue or pull request, rather than giving an agent unrestricted repository access. It's currently a public-preview feature, so I wouldn't treat it as a replacement for every established CI/CD workflow. For a simpler setup, Claude Code already provides an official GitHub Action. Inside Claude Code, you can run: /install-github-app Follow the setup instructions, and you can start assigning supported repository tasks through GitHub. You can also use OpenAI's Codex GitHub Action if that better fits your development stack. 3. DON'T AUTOMATE EVERY FAILURE IMMEDIATELY This is where I'd improve the usual approach. Not every failed test needs an AI agent. Some failures come from unavailable services, temporary network issues, or unstable tests. First, let ordinary scripts classify the failure. If a test is known to be flaky, rerun it under controlled conditions. If the problem is a formatting violation, use an existing formatter. If it's a dependency update, consider Dependabot or Renovate. Only send failures that actually require investigation to the AI agent. Why? Because deterministic tools are often cheaper, faster, and more predictable than asking an LLM to solve everything. 4. GIVE THE AGENT A CONTROLLED WORKSPACE Once a reproducible issue is identified, Claude Code or Codex receives the relevant logs and repository context. Its job is to find the cause and propose the smallest reasonable correction. But I'd impose several restrictions. The agent should work in an isolated branch or workspace. It shouldn't modify unrelated files. It shouldn't change protected CI configurations or acceptance criteria. And it should never have unrestricted access to production credentials. Most importantly, it shouldn't be able to approve its own changes. For repositories accepting external contributions, untrusted pull-request content must also remain separated from privileged credentials and automation. 5. BUILD A PROPER VERIFICATION LOOP Here's the technical detail that makes the biggest difference. Instead of asking the agent, "Did you fix the bug?", require actual evidence. For a reproducible software bug, I'd use a regression-testing approach: First, demonstrate that the relevant test fails on the original code. Then apply the proposed correction. Run the same test again. It should now pass. Next, run the broader test suite to check whether the correction introduced another problem. This is sometimes described as a red-green verification process. But there's another improvement worth adding. Don't allow the agent to repeatedly rewrite the tests until they agree with its implementation. Maintain protected acceptance tests or independent verification checks. Otherwise, the system can learn to satisfy an incomplete test suite rather than solve the underlying problem. The difference is significant. An AI agent generating a passing test is not necessarily proof that the software works. An independently defined test passing after a previously demonstrated failure provides much stronger evidence. 6. LET IT RETRY, BUT SET LIMITS If verification fails, the agent can inspect the error and attempt another correction. This is the feedback loop: Generate → Execute → Evaluate → Correct → Verify. But don't leave it running indefinitely. For example, you might allow: Three correction attempts. A maximum of 20 minutes. A fixed spending budget. A defined set of editable files. These are configurable safeguards, not universal limits. If the agent cannot resolve the issue within those boundaries, it should stop and explain what failed. That's much more useful than consuming tokens for hours while repeatedly making similar mistakes. 7. MAKE THE FINAL OUTPUT REVIEWABLE Once verification succeeds, the system should prepare a pull request. The pull request should explain: What originally failed. What caused the problem. Which files were changed. Which tests were executed. What remains uncertain. A developer can then examine the correction and approve or reject it. I wouldn't enable automatic merging for consequential changes until the workflow has demonstrated reliable performance. And even then, certain changes should always require human approval. 8. MEASURE THE RESULTS THAT MATTER Here's something many AI automation demonstrations completely overlook. Running more agents doesn't necessarily mean getting more work done. I'd measure: Cost per accepted fix. Time from failure detection to verified correction. Percentage of proposed fixes accepted without major rework. Number of regressions introduced. Amount of human review required. Suppose one system generates 40 pull requests but only eight are accepted. Another generates 12, and ten are accepted with fewer corrections. The second system may be considerably more useful, even though it produces less visible activity. And that leads to a broader point. The objective isn't to maximize AI activity. It's to maximize reliable results. WHERE THIS APPROACH BECOMES REALLY INTERESTING Once you've proven the workflow on software bugs, the same architecture can support other engineering tasks. Performance optimization: Let an agent propose code improvements and retain only changes that pass correctness tests and reproducible benchmarks. Dependency maintenance: Let existing automation identify updates, then use AI to investigate compatibility problems that ordinary tools cannot resolve. Automated research: Have an agent generate hypotheses, run controlled experiments, record outcomes, and retain improvements supported by measurable evidence. Codebase modernization: Let an agent migrate small, isolated components while independent tests confirm that existing behavior remains intact. Each application follows the same principle. Define the objective. Control the environment. Execute a bounded task. Measure the outcome. Use the feedback to determine the next action. And here's the bigger lesson. Prompt engineering is still important, but prompting alone doesn't make an AI system reliable. Harness engineering controls the environment and tools. Workflow orchestration manages execution and dependencies. Feedback loops support repeated improvement. Independent verification determines whether a result is acceptable. Human oversight remains responsible for consequential decisions. You don't need 100 AI agents to benefit from this. Start with one coding agent, one reproducible problem, and one trustworthy verification process. Get that working consistently. Then expand. The future of AI-assisted software development isn't simply writing more code with fewer prompts. It's building systems that can produce useful changes, demonstrate why they work, and recognize when they need human help. That's a much stronger foundation for autonomous AI engineering. Referenced by detailed artical by @Lummox_eth

xitter.cf/Bic_Revelation/status/… A QUEEN OPENED AN ICON. A PRESIDENT ORDERED A PROSECUTOR FIRED. SAME DAY. October 20, 1973. Sydney celebrated while Washington convulsed. That's one chapter of HISTORY EXTRA. Which moment surprised you most? History carries light when we remember it. ✝︎ OnThisDay