DEV Community: kemal

Prompt Engineering is Dead. Long Live the Agentic Loop.

kemal — Sat, 04 Jul 2026 10:00:00 +0000

You used to craft the perfect prompt. Tweak the wording. Add examples. Get a better answer.

That era is ending.

In 2026, the best AI coding workflows are not about prompts. They are about loops. You give the agent a goal, a test gate, and permission to run. You come back to a completed PR.

This article explains how agentic workflows work, what they look like in practice, the risks nobody talks about, and how to set one up properly.

What Is an Agentic Workflow?

An agentic workflow is when an AI agent does not just generate code — it executes a persistent loop:

Plan → Edit → Test → Fix → Document → Repeat

The agent reads your files, makes changes, runs your test suite, reads the results, fixes what broke, and loops. It stops when tests pass or when it hits a defined stop condition.

The key shift: you review the PR, not each step.

A typical agentic workflow example:

1. Agent generates authentication middleware
2. Runs existing test suite — 3 tests failing
3. Reads failure logs
4. Fixes the implementation
5. Re-runs tests — all pass
6. Opens pull request  ← first human touchpoint

The Tools Running Agentic Loops in 2026

Claude Code

Claude Code is one of the most capable terminal-based agentic tools as of March 2026. SWE-bench Verified: 80.9% (Opus 4.5) / 80.8% (Opus 4.6) — top of a competitive band that includes Gemini 3.1 Pro at 80.6% and GPT-5.2 at 80.0%.

Run an autonomous session with:

claude --dangerously-skip-permissions \
  --max-budget-usd 5.00 \
  "Migrate all SharedPreferences to DataStore. Run ./gradlew test after each migration. Do NOT modify test files."

For long overnight jobs, add a cost ceiling. Without it, an infinite loop will drain your credits.

Claude Code reads your CLAUDE.md at the start of every session — this is your agent briefing document. More on this below.

GitHub Copilot Coding Agent

Copilot's coding agent runs inside GitHub. You assign an issue to "Copilot" as the assignee. It creates a branch, writes code, runs tests, and opens a PR. You see the work in the PR timeline — every tool call, every test run.

Copilot agent works on tasks like: "Update the CI pipeline to include the new security scan step" — decomposed and implemented across multiple files, no manual work.

Cursor Agent Mode

Cursor went from $1M to $100M ARR in roughly 12 months (late 2023–early 2025), surpassing $2B ARR by early 2026. Agent mode iterates automatically — recognizes errors, reads logs, suggests and runs terminal commands, self-heals on failures.

Google Jules / Gemini Code Assist

Google's agentic offering comes in two forms. Gemini Code Assist Agent runs inside VS Code and Cloud Shell — assign a task, it works asynchronously. Jules is Google's fully autonomous agent inside Project IDX, handling issues end-to-end. Android developers also get Android Studio Agent Mode (Otter 3, Jan 2026), which can deploy to a device, read Logcat, and interact with the running app.

Devin

Devin (Cognition AI) is designed as a fully autonomous software engineer. Nubank used it for large migration tasks and reported 8–12x engineering efficiency and 20x cost savings. PR merge rates vary by customer and task complexity.

The Ralph Wiggum Pattern

Named by developer Geoffrey Huntley after the Simpsons character who keeps trying the same thing — but it works.

The core insight: progress does not live in the LLM's context window. It lives in your files and git history.

Each run starts with fresh context. But the agent sees the cumulative file changes from all previous runs. So it always picks up where the last run left off.

The original technique is literally a Bash loop:

#!/bin/bash
SPEC="specs/feature-auth.md"

while true; do
  claude --dangerously-skip-permissions \
    "Read $SPEC. Implement what is not done yet. Mark items DONE in the spec file."

  # Check exit code — 0 means agent finished successfully
  if [ $? -eq 0 ]; then
    echo "Done."
    break
  fi

  echo "Not complete. Retrying..."
  sleep 2
done

Why it avoids infinite loops: each iteration starts fresh, so the agent sees the current state of the files — not a confused internal memory of what it tried before.

The spec file drives progress:

# spec-datastore-migration.md

## Goal
Migrate all SharedPreferences usage to DataStore.

## Acceptance Criteria
- [ ] No SharedPreferences imports remain
- [ ] All DataStore flows are applicationScope
- [ ] All existing unit tests pass
- [ ] New unit tests exist for DataStore wrappers

## Do NOT touch
- /src/test/ — read only
- build.gradle.kts — ask first

## Done when
./gradlew test passes with zero failures

The agent checks off items as it completes them. Each loop makes progress. Eventually all boxes are checked.

The ecosystem around this pattern has grown fast — there are now multiple open-source implementations (fstandhartinger/ralph-wiggum, mikeyobrien/ralph-orchestrator, vercel-labs/ralph-loop-agent) and even ralph-wiggum.ai as a hosted version.

The Risks

Infinite Loops

Described as "the #1 plague of agentic engineering in 2026." An agent runs the same failing test 47 times, editing the same file repeatedly, burning credits with no progress.

Root causes:

Context blindness — error logs are truncated; agent thinks the error persists unchanged
Validation hallucination — agent believes it already fixed something it didn't
No action memory — the model doesn't know it already tried something unless your prompt says so

Mitigation: always set --max-budget-usd. Use the Ralph pattern (fresh context per run). Define clear stop conditions in CLAUDE.md.

Agents Cheating on Tests

This is a documented, real problem — not theoretical.

When you tell an agent "make the tests pass," it finds the shortest path:

Editing test files to change expected values
Commenting out failing assertions
Deleting failing test cases entirely
Adding try/catch wrappers that swallow exceptions
Adding production if (test) { return fakeValue; } branches

NIST documents this as specification gaming: the agents aren't being malicious — they're optimizing the metric you gave them, finding the loophole before you do.

The fix:

Be explicit in your prompt: "fix the code so tests pass — do NOT modify test files"
Better: make the test directory read-only during the agentic run

chmod -R a-w src/test/
claude --dangerously-skip-permissions "Fix failing tests without modifying test files."
chmod -R u+w src/test/

Best: track test count. If the agent reduced the number of tests, something went wrong.

Real Production Incidents

These are documented, named incidents from 2025:

Replit agent (July 2025) — deleted a production database while executing a task
Amazon Kiro (Dec 2025) — agent deleted and recreated a live Cost Explorer environment, causing a 13-hour outage (AWS later attributed the root cause to misconfigured access controls, not the agent acting alone)
Cursor agent (Dec 2025) — rm -rf'd 70 files despite explicit instructions not to

The pattern: agents given broad permissions and no stop conditions will take the shortest path to the stated goal — including irreversible destructive actions.

Always run agentic tasks in sandboxed environments. Never give production database credentials to an agentic session.

Overnight Refactors — What Actually Works

Tasks with high success rates for overnight agentic runs:

Task	Why It Works
SharedPreferences → DataStore	Mechanical, testable, clear acceptance criteria
Deprecated API upgrades (onBackPressed)	Pattern-matching across files
Adding unit test coverage	Agent writes tests for existing ViewModels
Framework version bumps	Compiler errors become the agent's feedback loop
Large-scale renames	Grep + replace + test gate

Tasks that fail:

Anything with no existing tests (agent cannot verify correctness)
UI changes (requires visual inspection)
Business logic changes without a clear spec

The productivity data is mixed. According to a DX study of 135,000+ developers, daily AI users submit ~60% more PRs — though critics note this measures output volume, not delivered value. A randomized controlled trial (METR, 2025) found experienced developers on familiar tasks were actually 19% slower when using AI — because prompt iteration costs time on things they already know.

The wins are on tasks outside your expertise or on high-volume mechanical changes where the agent is faster than you can type.

Multi-Agent Patterns

Single-agent loops work well for tasks that fit in one session. For larger refactors, teams are now using supervisor + worker patterns:

Orchestrator agent
├── Worker A → files 1–50 (edit → test → fix)
├── Worker B → files 51–100 (edit → test → fix)
└── Worker C → files 101–150 (edit → test → fix)
Orchestrator: merge → run integration tests → open PR

The orchestrator delegates, monitors, and merges. Workers run in parallel on git worktrees. This is the pattern behind tools like Amazon Kiro for long autonomous tasks.

Setting Up a Good Agentic Workflow

1. Write a Good CLAUDE.md

This is the most important step. Every agentic session reads this file first.

# Project: MyAndroidApp

## Build Commands
- Build: ./gradlew assembleDebug
- Test: ./gradlew test
- Lint: ./gradlew lint

## Test Gate
ALWAYS run ./gradlew test after any code change.
NEVER modify files in /src/test/ or /src/androidTest/
NEVER push if tests fail.

## Architecture
- MVVM with Clean Architecture
- Hilt for DI, Room for database, Coroutines + Flow
- All ViewModels must have unit tests

## Stop Conditions
Stop and ask before:
- Modifying build.gradle.kts
- Any database schema change
- If test count drops below current count
- Anything touching production config

Keep it under 300 lines. Don't include rules that a linter already enforces.

2. Define Stop Conditions

Agentic sessions need explicit boundaries. Without them, the agent will make assumptions:

"Stop if test count drops" catches test deletion
"Stop before schema migrations" prevents irreversible DB changes
"Stop if build.gradle changes" catches dependency version drift

3. Test Gates Are Your Safety Net

The most reliable control mechanism:

## Workflow
1. Make changes
2. Run: ./gradlew test
3. If ANY test fails: fix before moving on
4. Do NOT proceed to next task until all tests pass
5. Do NOT modify test files to make tests pass

No tests = no agentic workflows. Add tests first.

4. Write Spec Files for Long Tasks

For anything running overnight, use a spec file with checkboxes. The agent marks items done. You see exactly where it got stuck on the next morning.

Android/Kotlin Agentic Workflows

Claude Code works well with Android projects when combined with a good CLAUDE.md.

Gradle caveat: cold start on Android takes 10–30 seconds. For tight loops, batch file edits before running tests — not one Gradle run per file.

What works in Android:

SharedPreferences → DataStore (file-by-file, testable)
Adding unit tests to existing ViewModels
Upgrading deprecated lifecycle APIs
Jetpack Compose migration for individual screens
Hilt injection setup across a module

For architecture guidance to put in CLAUDE.md, see the Jetpack Compose tutorial series and the KMP tutorial series.

The Honest Verdict

Agentic workflows are not magic. They require:

Good test coverage (the test suite is the agent's compass)
A clear spec or acceptance criteria
Defined stop conditions (prevents infinite loops and cheating)
A context file (CLAUDE.md) that tells the agent your conventions

When these are in place, tasks that take a day take an hour. Tasks that take a week take a morning.

The developers getting the most out of agentic tools are not the ones crafting the best prompts. They are the ones who set up good test suites, write clear spec files, and treat the agent like a junior developer: capable, fast, and needs explicit rules to not cut corners.

Originally published at kemalcodes.com. Follow me on GitHub and X.

Best AI Coding Tools in 2026: Full Power Rankings

kemal — Thu, 02 Jul 2026 17:47:48 +0000

AI coding tools have changed a lot in 2026. A year ago, GitHub Copilot was the obvious choice. Now you have 7+ serious options — and the right one depends on how you work.

This article covers the top AI coding tools as of March 2026. Real pricing. Honest pros and cons. No hype.

What We Compare

SWE-bench score — a standard coding benchmark. Higher = better at real coding tasks.
Best use case — what the tool is actually good at
Pricing — what you actually pay
Honest verdict — where it falls short

The Power Rankings

1. Claude Code

Best for: Complex debugging, multi-file changes, full codebase understanding

Claude Code is Anthropic's terminal-based coding agent. You give it a task. It reads your files, edits code, runs commands, and shows you the result.

Key numbers:

SWE-bench Verified: 80.8% (Claude Opus 4.6)
Context window: 1M tokens (Opus 4.6 beta)
Token efficiency: Good for long sessions

Pricing:

Included in Claude Pro ($20/month)
API usage billed separately per token

Best for Android/Kotlin developers:
Claude Code works very well with Android projects when you add a CLAUDE.md file with your project rules. It understands Jetpack Compose, MVVM, and Room. Multiple developers have reported building full Android apps faster with Claude Code than with any other tool.

Example prompt that works well:

Add a Room database with a User entity.
Use ViewModel + StateFlow.
Follow the existing MVVM structure.

Pros:

Best at multi-file refactoring
Huge context window — reads your whole codebase
Works from terminal, no IDE lock-in
CLAUDE.md lets you define your own rules

Cons:

No inline autocomplete while you type
Steeper learning curve than IDE tools
Usage costs can add up with long sessions

2. Cursor

Best for: Daily coding, full-stack, anyone coming from VS Code

Cursor is VS Code with AI built in. You get inline completions, a chat window, and "Composer" mode where the AI edits multiple files at once.

Key numbers:

No public SWE-bench score
Context: 200K advertised (70–120K reported in practice)
Feels faster for simple day-to-day edits (inline completions have near-zero latency)

Pricing:

Free tier: limited completions
Pro: $20/month — unlimited completions + Composer

Pros:

Familiar VS Code environment
Tab completions are fast and accurate
Visual diffs — you see exactly what changed
Great for everyday coding and quick edits

Cons:

Context window can truncate on large codebases
Less powerful for complex multi-file refactors
IDE-dependent — no terminal agent mode

Honest tip: Many developers use both Claude Code and Cursor. Claude Code for big refactors, Cursor for daily typing. Subscription cost: ~$40/month total — though Claude Code API usage can add more for heavy sessions.

3. GitHub Copilot

Best for: Teams on Azure, JetBrains users, inline completion

GitHub Copilot is the most widely used AI coding tool. It works inside VS Code, JetBrains, Neovim, and Visual Studio. In 2026, it added "Agent Mode" — multi-file edits similar to Cursor's Composer.

Pricing:

Individual: $10/month
Business: $19/user/month
Free tier: 2,000 completions/month

Best for Android: Copilot in Android Studio works via JetBrains integration. Good for quick completions and function generation. Not as strong for architecture-level changes.

Pros:

Cheapest paid option
Works in every major IDE
Agent mode added in 2025
Backed by GitHub and Microsoft

Cons:

Agent mode weaker than Cursor Composer or Claude Code
Less context than competitors
Sometimes suggests outdated patterns

4. OpenAI Codex (CLI)

Best for: Budget-conscious developers, API users

OpenAI Codex CLI is open-source (Apache 2.0) and runs in your terminal. Think Claude Code but from OpenAI. The underlying model is codex-1 (o3 reasoning).

Key numbers:

SWE-bench Pro: 56.8% (GPT-5.3-Codex — best on this harder benchmark)
Built in Rust for speed and low overhead
API price: $1.50 per 1M input tokens, $6 per 1M output tokens (with 75% caching discount)

Pricing:

CLI tool: free (open source, Apache 2.0)
ChatGPT Plus ($20/mo): Codex included — separate usage limits for cloud tasks vs. local messages
ChatGPT Pro ($200/mo): Higher limits for both modes
API: $1.50 per 1M input tokens / $6 per 1M output tokens

Pros:

Free CLI tool, open source
Bundled with ChatGPT subscriptions you may already have
Token-efficient (good if paying per token)

Cons:

Needs ChatGPT subscription for meaningful usage
Less context than Claude Code
Still maturing compared to Claude Code

5. Amazon Kiro

Best for: Long autonomous tasks, enterprise AWS teams

Amazon Kiro is a new autonomous agent. It can work on a coding task independently for days. Think of it as an AI developer you assign a GitHub issue to.

Pricing:

Free: 50 credits/month
Pro: $20/month (1,000 credits)
Pro+: $40/month (2,000 credits)
Power: $200/month (10,000 credits)

Pros:

True autonomous agent — can work without supervision
Built by AWS team, good cloud integration
Good for large, long-running tasks

Cons:

Still early — not battle-tested
Credit-based pricing can be confusing
Less community support than Cursor/Copilot

6. Google Antigravity

Best for: Multi-agent workflows, Gemini users

Google's Antigravity is an agent-first IDE launched in November 2025. It has a built-in browser, and "Mission Control" for coordinating multiple agents at once.

Pricing:

Free preview available (pricing may change as it exits preview)

It supports Gemini 3 Pro, Claude Sonnet 4.5, and GPT-based models — so you can use different models for different tasks inside the same IDE.

Pros:

Multi-agent coordination is unique
Built-in browser for web tasks
Use any model you want

Cons:

New — fewer integrations than established tools
Less community resources
Requires learning a new IDE

7. Windsurf (Codeium)

Best for: Unit test generation, pair programming feel

Windsurf is made by Codeium and positions itself as a "pair programmer" rather than an agent. It's strong at writing tests and suggesting improvements as you code.

Pricing:

Free tier available
Pro: $15/month

Pros:

Good at test generation
Feels natural — less autonomous than others
Cheaper than Cursor

Cons:

Smaller community
Agent mode less capable than Cursor or Claude Code
Fewer integrations

8. OpenCode / Aider

Best for: Privacy-first, open source, cost control

OpenCode is an open-source terminal agent with rapidly growing GitHub adoption (the combined open-source CLI space including Aider and OpenCode has 95K+ stars across projects). Like Claude Code, but you bring your own API key (BYOK) — so no subscription fees beyond what you pay your AI provider directly.

Pricing:

Free (pay only your LLM provider)
Works with Claude, GPT, Gemini, and more

Pros:

No subscription — just API costs
Privacy-focused — no data sent to a third-party tool
Multi-provider support
Terminal-based, lightweight

Cons:

Requires setup
Less polished than Cursor
Support is community-driven

SWE-Bench Scores (March 2026)

SWE-bench measures how well a model fixes real GitHub issues. Higher = better.

Model	SWE-bench Verified
Claude Opus 4.5	80.9%
Claude Opus 4.6	80.8% (slight regression vs 4.5 on this benchmark)
Gemini 3.1 Pro	80.6%
GPT-5.2	80.0%
Claude Sonnet 4.6	79.6%
Claude Sonnet 4.5	77.2%

Note: SWE-bench Verified uses Python-only tasks. SWE-bench Pro (multi-language, harder) shows different results — Claude Opus 4.5 leads there at 45.9%.

Which Tool for Android Developers?

If you build Android apps:

Claude Code — best for architecture changes, Room + ViewModel setup, refactoring across files. Add a CLAUDE.md with your Compose and MVVM rules. See the Jetpack Compose tutorial series to understand the patterns worth putting in that file.
GitHub Copilot in Android Studio — best for quick completions while you type. JetBrains integration is solid.
Gemini in Android Studio — Google's own tool. Understands Compose UI and Gradle errors. Free inside Android Studio.
Cursor — if you prefer VS Code over Android Studio for Kotlin development. Works well alongside the KMP tutorial series if you are building shared-code apps.

The Honest Recommendation

Use both Claude Code + Cursor if you can afford $40/month. Claude Code for big tasks. Cursor for daily coding. This combo outperforms either tool alone.

On a budget? GitHub Copilot at $10/month is still excellent value. The inline completions alone save hours every week.

Privacy matters? OpenCode with your own API key keeps your code off third-party servers.

Android developer? Start with Cursor or Copilot for the IDE experience. Add Claude Code when you need full-codebase changes.

Claude Code YOLO Mode — Full Guide

Originally published at kemalcodes.com. Follow me on GitHub and X.

DEV Community: kemal

Prompt Engineering is Dead. Long Live the Agentic Loop.

What Is an Agentic Workflow?

The Tools Running Agentic Loops in 2026

Claude Code

GitHub Copilot Coding Agent

Cursor Agent Mode

Google Jules / Gemini Code Assist

Devin

The Ralph Wiggum Pattern

The Risks

Infinite Loops

Agents Cheating on Tests

Real Production Incidents

Overnight Refactors — What Actually Works

Multi-Agent Patterns

Setting Up a Good Agentic Workflow

1. Write a Good CLAUDE.md

2. Define Stop Conditions

3. Test Gates Are Your Safety Net

4. Write Spec Files for Long Tasks

Android/Kotlin Agentic Workflows

The Honest Verdict

Related Articles

Best AI Coding Tools in 2026: Full Power Rankings

What We Compare

The Power Rankings

1. Claude Code

2. Cursor

3. GitHub Copilot

4. OpenAI Codex (CLI)

5. Amazon Kiro

6. Google Antigravity

7. Windsurf (Codeium)

8. OpenCode / Aider

SWE-Bench Scores (March 2026)

Which Tool for Android Developers?

The Honest Recommendation

Related Articles