<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Halfcycle</title>
    <description>The latest articles on DEV Community by Halfcycle (@halfcycle).</description>
    <link>https://dev.to/halfcycle</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4174134%2Fc77eb89b-97af-4262-ba4a-cd9150d857e9.png</url>
      <title>DEV Community: Halfcycle</title>
      <link>https://dev.to/halfcycle</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/halfcycle"/>
    <language>en</language>
    <item>
      <title>Agent skills for AI coding agents: how they work, how to write one, and where they stop</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Thu, 12 Nov 2026 15:27:16 +0000</pubDate>
      <link>https://dev.to/halfcycle/agent-skills-for-ai-coding-agents-how-they-work-how-to-write-one-and-where-they-stop-55dh</link>
      <guid>https://dev.to/halfcycle/agent-skills-for-ai-coding-agents-how-they-work-how-to-write-one-and-where-they-stop-55dh</guid>
      <description>&lt;p&gt;Halfcycle is a module that runs a five-layer build method inside your own Claude Code or OpenAI Codex (npx halfcycle).&lt;/p&gt;

&lt;p&gt;Every coding agent starts a session knowing nothing about how your team works. You can tell it everything up front, in a long instructions file that it reads before every task, or you can teach it in small pieces it picks up only when the work calls for them. Agent skills are the second way.&lt;/p&gt;

&lt;p&gt;A skill is a folder with one file in it that matters, &lt;code&gt;SKILL.md&lt;/code&gt;: a name, a one-line description, and the instructions for one job. The agent sees the name and description of every installed skill from the start of the session. It reads the rest only when a task matches. That one design choice, a short line always visible and the detail held back until needed, is why skills spread to most coding agents within a few months.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwiobwyssc641i8905xnz.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwiobwyssc641i8905xnz.webp" alt="A coding agent's context at the start of a session: a column of one-line skill descriptions, twelve of them, each a few words long, and one request at the top, &amp;quot;add a column to the orders table&amp;quot;, matching a single line, &amp;quot;database-migration&amp;quot;, which is drawn in amber" width="800" height="507"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Why skills matter now that agents write the code
&lt;/h2&gt;

&lt;p&gt;Before agents, a team's know-how lived in people. How we write migrations, which checks run before a release, why the payments module never calls the clock directly. A new engineer picked it up over months, from reviews and from being told.&lt;/p&gt;

&lt;p&gt;An agent does not pick anything up between sessions. Whatever it needs, it has to be given, every time. The first answer most teams reach for is one big instructions file, &lt;code&gt;CLAUDE.md&lt;/code&gt; or &lt;code&gt;AGENTS.md&lt;/code&gt;, and it works until it does not. Every line in it is read before every task, relevant or not, and every line competes for the agent's attention with the task itself. The file grows, the agent follows less of it, and somebody starts deleting rules to make room.&lt;/p&gt;

&lt;p&gt;Skills move the occasional knowledge out of that file. The migration procedure loads when somebody asks for a migration and stays out of the way otherwise. The always-true rules stay in the instructions file; the sometimes-needed procedures become skills. That split is most of the value.&lt;/p&gt;

&lt;h2&gt;
  
  
  Three things people mean by "agent skills"
&lt;/h2&gt;

&lt;p&gt;The phrase is used for three different things, and arguments about whether skills work are often two people meaning different ones.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The format.&lt;/strong&gt; A folder with a &lt;code&gt;SKILL.md&lt;/code&gt; file, YAML frontmatter at the top and Markdown instructions below, optionally with scripts, reference documents and templates beside it. Anthropic published it as an open specification at &lt;a href="https://agentskills.io/specification" rel="noopener noreferrer"&gt;agentskills.io&lt;/a&gt;, and Claude Code, OpenAI Codex and a long list of other tools now read the same files.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The collections.&lt;/strong&gt; Packs of ready-made skills shared on GitHub and in marketplaces: a frontend skill, a code review skill, a test-writing skill. Installing one is quick, and quality varies a great deal, because a skill written for someone else's codebase carries someone else's assumptions.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The idea.&lt;/strong&gt; Reusable know-how an agent can pick up on demand, in whatever file format. This is the sense people mean when they say an agent "has a skill" for something.&lt;/p&gt;

&lt;p&gt;This article is mostly about the first, because it is what you write and maintain, with notes on the second where it matters.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flqz2i2duvu5dk9c7w7ad.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flqz2i2duvu5dk9c7w7ad.webp" alt="Three columns. The format: a folder icon with SKILL.md inside, labelled what you write. The collections: a stack of folders from other people, labelled what you install. The idea: a cloud labelled reusable know-how, labelled what people mean in conversation" width="800" height="427"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What a skill is made of
&lt;/h2&gt;

&lt;p&gt;A skill is a directory named after the skill. Inside it:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;SKILL.md&lt;/code&gt;&lt;/strong&gt;, the only required file. It starts with frontmatter between two &lt;code&gt;---&lt;/code&gt; lines and continues with plain Markdown.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;scripts/&lt;/code&gt;&lt;/strong&gt;, optional: code the agent can run, for the steps that need to be exact every time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;references/&lt;/code&gt;&lt;/strong&gt;, optional: longer documents the agent reads only if the instructions send it there.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;assets/&lt;/code&gt;&lt;/strong&gt;, optional: templates, example files, schemas.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The frontmatter needs two fields. The open specification requires both; Claude Code will load a skill without them but recommends the description.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;name&lt;/code&gt;&lt;/strong&gt;: lowercase letters, numbers and hyphens, up to 64 characters, matching the folder name.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;description&lt;/code&gt;&lt;/strong&gt;: what the skill does and when to use it, up to 1,024 characters in the specification.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Tools add their own optional fields on top. Claude Code, for example, can stop the agent from loading a skill by itself (&lt;code&gt;disable-model-invocation&lt;/code&gt;), limit a skill to certain files (&lt;code&gt;paths&lt;/code&gt;), or pre-approve the tools it needs (&lt;code&gt;allowed-tools&lt;/code&gt;). Codex keeps its extras in a separate &lt;code&gt;agents/openai.yaml&lt;/code&gt; beside the skill. Fields a tool does not recognise are ignored, so a skill written to the shared fields works in both.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fj9mm608m2kahiat00nfw.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fj9mm608m2kahiat00nfw.webp" alt="A skill folder drawn as a tree: database-migration at the top, SKILL.md beneath it split into frontmatter, with name and description, and body, with the steps, and three optional folders, scripts, references and assets, each with one example file. The description line is in amber" width="800" height="547"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How an agent decides to use one
&lt;/h2&gt;

&lt;p&gt;Skills load in three stages, which the specification calls progressive disclosure.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;At the start of a session&lt;/strong&gt;, the agent is given the name and description of every installed skill. That is all. The specification puts this at about 100 tokens a skill.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;When a task matches a description&lt;/strong&gt;, the agent reads the whole &lt;code&gt;SKILL.md&lt;/code&gt;. The specification recommends keeping it under 5,000 tokens and 500 lines.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;When the instructions point somewhere&lt;/strong&gt;, the agent opens that reference file or runs that script, and nothing else in the folder.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;You can also call a skill by hand: in Claude Code it appears as a &lt;code&gt;/&lt;/code&gt; command, and in Codex you mention it with &lt;code&gt;$&lt;/code&gt; or pick it from &lt;code&gt;/skills&lt;/code&gt;. But the more common path is the automatic one, and the automatic one depends entirely on stage one. The agent does not read your skill to decide whether to read your skill. It reads one line.&lt;/p&gt;

&lt;p&gt;There is also a budget on that first stage. Codex gives the opening list of skills 2% of the context window by default (8,000 characters when it cannot tell the window size), and when many skills are installed it shortens descriptions first and drops some altogether, with a warning. Claude Code cuts each skill's listing at 1,536 characters. So a description competes twice: once for the agent's attention, and once for space.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flq990wksxcnowvcbjn7o.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flq990wksxcnowvcbjn7o.webp" alt="Three stages left to right. At start: every skill's name and description, about 100 tokens each. On a match: the whole SKILL.md, under 5,000 tokens recommended. When needed: one reference file or one script. The first stage is drawn in amber with the label &amp;quot;decided here&amp;quot;" width="799" height="373"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The description does the work
&lt;/h2&gt;

&lt;p&gt;Because the decision is made on one line, the description is the most important sentence in the skill, and the one most often written last and in a hurry.&lt;/p&gt;

&lt;p&gt;A weak description names a topic: "Helps with database stuff." The agent cannot tell whether "add a column to orders" is database stuff, or whether "why is this query slow" is. A strong description names the job, the words a person would use when they need it, and where it stops:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Write and check a database migration for this project's Postgres schema. Use when adding, renaming or removing a table, column, index or constraint, or when someone says "migration" or "schema change". Not for writing queries or fixing slow ones.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Three habits make descriptions trigger well:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Put the job and the trigger words first.&lt;/strong&gt; Codex's own guidance says so, because when descriptions get shortened, the end goes first.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Say when not to use it.&lt;/strong&gt; Two skills with overlapping descriptions will both look right, and the agent will pick one.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Test it with real requests.&lt;/strong&gt; Type five ways someone might ask for the job and check the skill loads for each; type two near-misses and check it does not.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fu9mm2opu0zdt4jpkrtut.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fu9mm2opu0zdt4jpkrtut.webp" alt="Two cards side by side. On the left, a weak description, &amp;quot;Helps with database stuff&amp;quot;, with three real requests below it, two marked missed and one marked wrong skill. On the right, the strong description with the job, the trigger words and the &amp;quot;not for&amp;quot; line highlighted, and the same three requests all marked matched" width="800" height="533"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  A worked example
&lt;/h2&gt;

&lt;p&gt;Here is a complete skill for a team on Postgres that writes migrations by hand. It is short on purpose: one job, steps in order, the checks spelled out, and the one exact step handed to a script.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;---
name: database-migration
description: Write and check a database migration for this project's Postgres schema. Use when adding, renaming or removing a table, column, index or constraint, or when someone says "migration" or "schema change". Not for writing queries or fixing slow ones.
---

&lt;span class="gu"&gt;# Database migration
&lt;/span&gt;
Migrations live in &lt;span class="sb"&gt;`db/migrations/`&lt;/span&gt;, one file per change, named
&lt;span class="sb"&gt;`YYYYMMDDHHMM_short_description.sql`&lt;/span&gt;. Each file has an &lt;span class="sb"&gt;`-- up`&lt;/span&gt; section and a
&lt;span class="sb"&gt;`-- down`&lt;/span&gt; section. Production runs them in name order.

&lt;span class="gu"&gt;## Steps
&lt;/span&gt;
1. Read the latest three migrations to match the house style.
2. Write the new file. The &lt;span class="sb"&gt;`down`&lt;/span&gt; section must undo the &lt;span class="sb"&gt;`up`&lt;/span&gt; section exactly.
3. If the change removes or renames a column, stop and ask: is anything still
   reading the old name? Search the code for it and show what you found.
4. If the change adds a column to a table with more than a million rows, add it
   as nullable first and backfill in a separate migration. Say why in a comment.
5. Run &lt;span class="sb"&gt;`scripts/check-migration.sh &amp;lt;file&amp;gt;`&lt;/span&gt;. It applies the migration to a scratch
   database, rolls it back, and applies it again. Do not continue if it fails.
6. Update &lt;span class="sb"&gt;`db/schema.sql`&lt;/span&gt; with the result and show the diff.

&lt;span class="gu"&gt;## Never
&lt;/span&gt;
&lt;span class="k"&gt;- &lt;/span&gt;Edit a migration that has already been merged. Write a new one.
&lt;span class="k"&gt;- &lt;/span&gt;Put data changes and schema changes in the same file.

For the list of large tables, see &lt;span class="sb"&gt;`references/large-tables.md`&lt;/span&gt;.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Notice what it does not contain. There is no explanation of what a migration is, which the agent already knows, and nothing about queries, which belongs to another skill or none. The judgement calls are written as questions the agent must stop and ask, because those are the steps an agent will otherwise answer on its own. The one step that has to be exact, applying and rolling back, is a script, so it does not depend on the agent following prose.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5ztrum5b8m866mte1xel.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5ztrum5b8m866mte1xel.webp" alt="The example skill laid out as a flow: the request comes in, the description matches, the agent reads the steps, two of them are marked &amp;quot;stops to ask&amp;quot;, one is marked &amp;quot;runs a script&amp;quot;, and the result is a migration file and a schema diff. The two stop-and-ask steps are in amber" width="800" height="427"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Where skills fit with everything else
&lt;/h2&gt;

&lt;p&gt;Skills are one of several ways to shape what an agent does, and most trouble with them comes from using a skill for a job another piece does better.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The instructions file&lt;/strong&gt; (&lt;code&gt;CLAUDE.md&lt;/code&gt;, &lt;code&gt;AGENTS.md&lt;/code&gt;) is read at the start of every session. It is the place for rules that are true all the time: the stack, the test command, what never to touch.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Skills&lt;/strong&gt; are read when a task matches. They are the place for procedures that apply some of the time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hooks&lt;/strong&gt; run code before or after the agent acts, whatever the agent intended. They are the place for anything that must happen, because a hook does not depend on the agent reading or agreeing.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Subagents&lt;/strong&gt; run a task in a separate context and hand back a result. They are the place for work that should not see, or be swayed by, everything the main session has seen, such as a review.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tools and MCP servers&lt;/strong&gt; give the agent new things it can do: query a database, open a ticket.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The line that matters most is between the second and third. A skill can say "run the tests". Only a hook, or a check outside the agent, can make sure they ran.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxd3mb90pb8gqp78gcgt0.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxd3mb90pb8gqp78gcgt0.webp" alt="Five rows, one per mechanism, with two columns: when it loads and whether it is enforced. Instructions file: every session, followed if read. Skill: when the task matches, followed if read. Hook: on every action, enforced. Subagent: when delegated, separate context. Tools: when called, adds abilities. The hook row's &amp;quot;enforced&amp;quot; is in amber" width="800" height="507"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The loop a skill lives in
&lt;/h2&gt;

&lt;p&gt;A skill is not finished when it is written. The ones that stay useful go round a short loop.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Notice the repeat.&lt;/strong&gt; The third time you explain the same procedure to an agent, it is a skill.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write the smallest version&lt;/strong&gt; that does the job: description first, then the steps.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Test the trigger&lt;/strong&gt; with real requests and near-misses.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Use it on real work&lt;/strong&gt; and watch where the agent goes wrong.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fix the cause in the skill&lt;/strong&gt;, not in the conversation. A correction typed into one session teaches one session.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Prune.&lt;/strong&gt; Delete steps the agent gets right without being told.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The fifth step is the one teams skip. A correction made in chat feels like progress and disappears when the session ends. The same correction written into the skill holds for everyone, next time.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fid1vykb7wpokwl73tit0.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fid1vykb7wpokwl73tit0.webp" alt="A loop of six steps: notice the repeat, write the smallest version, test the trigger, use it on real work, fix the cause in the skill, prune. An arrow from &amp;quot;use it&amp;quot; back to &amp;quot;fix the cause&amp;quot; is in amber, labelled &amp;quot;where most skills improve or rot&amp;quot;" width="800" height="600"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Six ways skills fail
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;It never loads.&lt;/strong&gt; The description names a topic rather than a job, or uses words nobody types. The skill sits in the folder, correct and unused, and the agent improvises.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It loads for the wrong job.&lt;/strong&gt; The description is so broad that it matches requests it was never meant for, and the agent follows a migration procedure while fixing a query.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Two skills fight.&lt;/strong&gt; Two collections each ship a "code-review" skill, or two of your own overlap. Codex does not merge skills with the same name, so both appear. Claude Code lets one location override another. Either way, which one runs depends on details nobody is watching.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It is too big.&lt;/strong&gt; A 900-line skill is loaded whole the moment it triggers and stays in the session, crowding out the task. In Claude Code, a loaded skill's content stays in context for the rest of the session, and only its first 5,000 tokens survive when the session is compacted.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It goes stale.&lt;/strong&gt; The skill says migrations live in &lt;code&gt;db/migrations/&lt;/code&gt;; the team moved them six months ago. The agent follows the skill, because the skill is what it was given.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It is advice, not a check.&lt;/strong&gt; The skill says "run the tests before you finish". The agent, deep in a long task, does not. Nothing notices. A skill is text the agent reads, and an agent under pressure skips text.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fx07ofvsfat9ew1wii4xs.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fx07ofvsfat9ew1wii4xs.webp" alt="Six small panels, one per failure: never loads, a folder with no arrows reaching it; wrong job, an arrow going to the wrong folder; two skills fight, two folders with the same name; too big, a long page pushing the task out of a box; stale, a skill saying one path and the code at another; advice not a check, &amp;quot;run the tests&amp;quot; with a dashed arrow that stops short. The last panel is in amber" width="800" height="573"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How many skills, and how big
&lt;/h2&gt;

&lt;p&gt;A skill should do one job, and you should have as many as you have recurring jobs, not as many as you can find.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;One job per skill.&lt;/strong&gt; "Database migration" is a job. "Backend" is not. If the description needs the word "and" to cover two unrelated things, it is two skills.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write one when a procedure repeats&lt;/strong&gt;, not in advance. A skill for a task you do once a quarter will be stale the next time you need it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Prefer short.&lt;/strong&gt; Most good skills are under a hundred lines. Move long references into &lt;code&gt;references/&lt;/code&gt; so they load only when needed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Watch the total.&lt;/strong&gt; Every installed skill costs a line at the start of every session. Thirty skills you never use make it harder for the agent to find the three you do.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;There is a harder sizing problem that skills do not solve, which comes up in the last two sections: a skill does the same thing every time it runs, whatever the size of the change in front of it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8pb6j8h0chp8ybmnsmlt.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8pb6j8h0chp8ybmnsmlt.webp" alt="A bar showing the opening list of skills filling up as more are installed. At five skills, every description fits in full. At thirty, descriptions are shortened. At eighty, some skills are dropped from the list with a warning. The dropped section is in amber" width="800" height="427"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  When a skill goes stale
&lt;/h2&gt;

&lt;p&gt;The codebase moves every week. A skill moves when someone remembers it. The gap between the two opens quietly, and an agent cannot see it: it follows the skill confidently, because following instructions is what it was asked to do.&lt;/p&gt;

&lt;p&gt;Three habits keep the gap small:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Point at the code, do not copy it.&lt;/strong&gt; "Match the style of the latest three migrations" stays true when the style changes. A pasted example does not.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Change the skill in the same pull request&lt;/strong&gt; as the change that makes it wrong. If the migrations folder moves, the skill's path changes in the same commit.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Read your skills when something goes wrong.&lt;/strong&gt; When an agent does something odd and confident, check whether a skill told it to.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fynj9lqokom0gf7egq3cq.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fynj9lqokom0gf7egq3cq.webp" alt="On the left, a skill that says &amp;quot;migrations live in db/migrations&amp;quot;. On the right, the codebase, where migrations now live in database/changes. Between them, the agent follows the skill and writes to the old folder. The arrow from the skill to the old folder is in amber" width="800" height="427"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How to judge a skill
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Question&lt;/th&gt;
&lt;th&gt;A good answer&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Does the description name a job, not a topic?&lt;/td&gt;
&lt;td&gt;It says what the skill does in the first few words&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Does it include the words people actually type?&lt;/td&gt;
&lt;td&gt;"migration", "schema change", not only "DDL"&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Does it say when not to use it?&lt;/td&gt;
&lt;td&gt;One line that rules out the nearest neighbour&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Did you test it on real requests?&lt;/td&gt;
&lt;td&gt;Five that should load it, two that should not&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Does it do one job?&lt;/td&gt;
&lt;td&gt;No "and" joining two unrelated tasks&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Is it short?&lt;/td&gt;
&lt;td&gt;Under a few hundred lines, references split out&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Are the judgement calls written as stop-and-ask?&lt;/td&gt;
&lt;td&gt;The agent is told where to stop, not just what to do&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Is anything that must happen enforced outside the skill?&lt;/td&gt;
&lt;td&gt;Tests, checks and approvals run by a hook or a reviewer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Does it point at the code rather than copy it?&lt;/td&gt;
&lt;td&gt;Paths and examples that update when the code does&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  What a skill cannot do on its own
&lt;/h2&gt;

&lt;p&gt;Skills are good at one thing: putting the right procedure in front of the agent at the right moment. Some of what teams hope skills will do sits outside that.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A skill cannot decide what should be built.&lt;/strong&gt; It can tell the agent how your team writes a migration. It cannot tell anyone whether this feature needs a migration, which tables it should touch, or what happens to existing rows. Those are decisions, and a skill holds procedures.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A skill cannot make sure it was followed.&lt;/strong&gt; It is text. Whether the agent read it all, skipped a step under pressure, or stopped where it was told to stop, the skill cannot see. That needs a check that runs whether or not the agent agrees, and someone, or something, that did not write the work to look at it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A skill gives the same ceremony to every change.&lt;/strong&gt; A code review skill runs the same review on a one-word copy fix and on a change to how payments are stored. A folder of instructions cannot tell those apart, so it either does too much for the small change or too little for the risky one. This is the limit people hit after a few months, and it is structural: the skill is written once and then read the same way each time.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A skill does not learn from anyone else.&lt;/strong&gt; When one team finds that their migration skill missed a case, the fix lives in their repository. A team down the road with the same gap will find it the same way.&lt;/p&gt;

&lt;h2&gt;
  
  
  How Halfcycle does it
&lt;/h2&gt;

&lt;p&gt;Halfcycle runs inside Claude Code or OpenAI Codex and installs as a small set of commands and skills in each, so you start it the way you start anything else in those tools. What it adds is the part skills cannot do alone.&lt;/p&gt;

&lt;p&gt;The method is not stored in those files. It is served to the session one step at a time, and the step you get depends on the change in front of you. Each request is sorted first: a small change takes a short path, an ordinary feature gets &lt;a href="https://halfcycle.ai/writing/spec-driven-development" rel="noopener noreferrer"&gt;a spec&lt;/a&gt; and a review, and a change touching money, permissions or stored data gets the full treatment. You are told which path and why. That is the property a folder of skills cannot have, because the folder reads the same for every change.&lt;/p&gt;

&lt;p&gt;Before any code, the open decisions are asked one at a time, each with a recommendation, and recorded where every agent in the project reads them. The plan is reviewed by an agent that did not write it. During the build, each piece is reviewed by an agent that did not build it, every edit is checked as it is made, and the agent asks you in plain words before a command that would delete work, wipe data, read credentials, publish or deploy. Those checks run whether or not the agent remembers them, which is the difference between advice and a check.&lt;/p&gt;

&lt;p&gt;And it keeps getting better without you maintaining it. When a project implementation goes wrong, both the cause and the fix are kept, and both reach every other project automatically. So most of those problems never arrive on your project, and the ones that do arrive with the answer attached. What travels back is the shape of a problem, never your code or your documents, and we do not train on anyone's work.&lt;/p&gt;

&lt;p&gt;If you have built your own set of skills for planning and review, you will recognise the parts. The difference is that nobody on your team has to keep them current, and they size themselves to the work.&lt;/p&gt;

&lt;h2&gt;
  
  
  The honest limits
&lt;/h2&gt;

&lt;p&gt;Halfcycle does not replace the skills that hold your team's own knowledge. How you deploy, how your design system names things, which tables are large: those belong in your own skills and instructions, and they keep working alongside it.&lt;/p&gt;

&lt;p&gt;It also needs a connection, because the method is served rather than stored in your repository. And skills themselves are young. The specification is about a year old, tools still differ on the optional fields, and a skill that behaves well in one agent can behave differently in another. Test yours in the tools your team actually uses.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;p&gt;Checked 12 November 2026.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://agentskills.io/specification" rel="noopener noreferrer"&gt;Agent Skills specification&lt;/a&gt;: format, field limits, progressive disclosure and size guidance.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://code.claude.com/docs/en/skills" rel="noopener noreferrer"&gt;Claude Code: skills&lt;/a&gt;: skill locations, optional fields, the 1,536-character listing limit, how loaded skills stay in context and survive compaction.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://learn.chatgpt.com/docs/build-skills" rel="noopener noreferrer"&gt;OpenAI Codex: build skills&lt;/a&gt;: skill locations, explicit and implicit activation, the opening-list budget, description guidance.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;Getting started&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx halfcycle
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Run that in the folder you want to work in, then open it in Claude Code or OpenAI Codex and say what you are building. Needs Node 20 or newer. There is nothing to learn first, and it tells you what is next when it is next.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://halfcycle.ai" rel="noopener noreferrer"&gt;halfcycle.ai&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claudecode</category>
      <category>productivity</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>GSD Core vs Halfcycle: the closest pair, and where they differ</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Thu, 05 Nov 2026 17:21:24 +0000</pubDate>
      <link>https://dev.to/halfcycle/gsd-core-vs-halfcycle-the-closest-pair-and-where-they-differ-227g</link>
      <guid>https://dev.to/halfcycle/gsd-core-vs-halfcycle-the-closest-pair-and-where-they-differ-227g</guid>
      <description>&lt;p&gt;&lt;em&gt;We make Halfcycle, so read this with that in mind. GSD Core is open source and well made; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;GSD Core, formerly Get Shit Done, runs your coding agent through a phase loop: discuss, plan, execute, verify, ship, with heavy work done by fresh agents so the main session does not fill up. Of the open frameworks, it is the closest to Halfcycle.&lt;/p&gt;

&lt;h2&gt;
  
  
  What GSD Core does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Product-level planning&lt;/strong&gt;: a project, requirements and a roadmap of phases. Halfcycle does this too, with the architecture and a design for each component.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Parallel agents with fresh context&lt;/strong&gt;, in waves, on separate copies of the code. Halfcycle does this too.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hooks that block&lt;/strong&gt; reading secret files and damaging its planning files. Halfcycle checks risky actions before they happen too, and asks you in plain words.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A verifier&lt;/strong&gt; that checks work against the phase's goals. Halfcycle does this too, and reviews each task twice before it is added.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Many agents, offline.&lt;/strong&gt; Halfcycle works with Claude Code and OpenAI Codex, with OpenCode and an offline fallback coming soon.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where they differ
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Learning.&lt;/strong&gt; GSD Core's is off by default and stays on your machine. Halfcycle learns from every project it runs on: the cause and the fix reach yours automatically. What travels is the shape of a problem, never your code, and we do not train on your work.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Where the method lives.&lt;/strong&gt; GSD Core is installed; it tells you when an update is out and you run it. Halfcycle is served one step at a time, so improvements arrive without updating.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sizing.&lt;/strong&gt; GSD Core has quick commands you choose to use. Halfcycle decides from the parts of your system a change touches, and tells you why.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Testing the running app.&lt;/strong&gt; GSD Core has you test items one at a time, with an optional check that reads the running UI. Halfcycle clicks through the live app in a browser at the end of each phase.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Watching it.&lt;/strong&gt; A status line in the terminal, or a console with the whole build and your approvals.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  When GSD Core is the better choice
&lt;/h2&gt;

&lt;p&gt;You use Cursor or another agent, you need to work offline, you want to read and tune every setting, or you prefer the terminal.&lt;/p&gt;

&lt;p&gt;Full comparison: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-gsd" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-gsd&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claudecode</category>
      <category>opensource</category>
      <category>programming</category>
    </item>
    <item>
      <title>BMAD vs Halfcycle: personas you direct, or a team that runs itself</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Thu, 05 Nov 2026 17:09:39 +0000</pubDate>
      <link>https://dev.to/halfcycle/bmad-vs-halfcycle-personas-you-direct-or-a-team-that-runs-itself-1pbk</link>
      <guid>https://dev.to/halfcycle/bmad-vs-halfcycle-personas-you-direct-or-a-team-that-runs-itself-1pbk</guid>
      <description>&lt;p&gt;&lt;em&gt;We make Halfcycle, so read this with that in mind. BMAD is open source and well made; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The BMAD Method adds the roles of an agile team to your coding tool as skills and named personas: analyst, product manager, architect, developer and more, each with its own commands.&lt;/p&gt;

&lt;h2&gt;
  
  
  What BMAD does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Product-level planning.&lt;/strong&gt; Product brief, PRD, UX design, architecture and stories. Halfcycle does this too: a product spec, the architecture, the phases and a design for each component.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reviews from several angles&lt;/strong&gt;, each finding sorted with a reason. Halfcycle does this too: each task is reviewed twice by an agent that did not build it, and each finding is recorded with its outcome.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The smallest safe route inside a build.&lt;/strong&gt; Halfcycle does this too, and makes the call before the work starts as well.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Generated API and end-to-end tests.&lt;/strong&gt; Halfcycle runs tests before and after every change, and clicks through the live app in a browser at the end of each phase.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open source, most coding tools.&lt;/strong&gt; Halfcycle works with Claude Code and OpenAI Codex too, with OpenCode coming soon.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What Halfcycle adds
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Nobody has to drive.&lt;/strong&gt; In BMAD you choose how much planning a change gets and call each persona. Halfcycle sizes the process from the parts of your system a change touches and tells you why.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Parallel building.&lt;/strong&gt; BMAD runs one build session at a time; parallel work needs a separate coordination layer. Halfcycle runs builders and reviewers at once, each on its own copy of the code.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A console&lt;/strong&gt;, instead of files and a status command: progress, phases, the system design, every agent, and approvals recorded part by part.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Learning across projects.&lt;/strong&gt; BMAD keeps project context. Halfcycle learns from every project it runs on: the cause and the fix reach yours automatically (the shape of a problem, never your code).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Risky actions checked before they happen.&lt;/strong&gt; BMAD's docs describe nothing that blocks them.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  When BMAD is the better choice
&lt;/h2&gt;

&lt;p&gt;You want open source you can extend, you work offline, you use another coding tool, or you like directing each role yourself.&lt;/p&gt;

&lt;p&gt;Full comparison: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-bmad" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-bmad&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claudecode</category>
      <category>agile</category>
      <category>programming</category>
    </item>
    <item>
      <title>Spec Kit vs Halfcycle: a path through each feature, or the whole build</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Thu, 05 Nov 2026 17:09:16 +0000</pubDate>
      <link>https://dev.to/halfcycle/spec-kit-vs-halfcycle-a-path-through-each-feature-or-the-whole-build-23j9</link>
      <guid>https://dev.to/halfcycle/spec-kit-vs-halfcycle-a-path-through-each-feature-or-the-whole-build-23j9</guid>
      <description>&lt;p&gt;&lt;em&gt;We make Halfcycle, so read this with that in mind. Spec Kit is open source and well made; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Spec Kit is GitHub's toolkit for spec-driven development. You set principles once, then run its commands in order: specify, clarify, plan, tasks, analyze, implement, converge.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Spec Kit does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A paper trail per feature&lt;/strong&gt;: spec, plan, task list and checklists in your repository. Halfcycle does this too, and adds the product spec, the architecture and the phases above them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It checks its own documents.&lt;/strong&gt; Analyze reports gaps across spec, plan and tasks; converge adds tasks for what is missing. Halfcycle does this too: a fresh agent reviews each phase's specs, and the finished phase is checked against every requirement.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Almost any coding agent&lt;/strong&gt;, Copilot and Claude Code included. Halfcycle works with Claude Code and OpenAI Codex too, with OpenCode coming soon.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Extensible and offline.&lt;/strong&gt; Halfcycle needs its service, with an offline fallback coming soon.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What Halfcycle adds
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The level above the feature.&lt;/strong&gt; Spec Kit leaves the stack and architecture to you at the plan step. Halfcycle works out the product and its architecture with you.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Process sized to the change.&lt;/strong&gt; Spec Kit has a shorter path for smaller features, and you choose. Halfcycle decides from the parts of your system a change touches, and tells you why.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A team, not one agent.&lt;/strong&gt; By default one agent works through Spec Kit's task list, and its docs describe no independent reviewer. In Halfcycle, builder and reviewer agents work in parallel, and each task is reviewed twice by an agent that did not build it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The running app.&lt;/strong&gt; Spec Kit's checklists test the requirements. Halfcycle clicks through the live app in a browser at the end of each phase.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Learning and a console.&lt;/strong&gt; It learns from every project it runs on (the shape of a problem, never your code), and shows the whole build in a console.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  When Spec Kit is the better choice
&lt;/h2&gt;

&lt;p&gt;Your team uses Copilot or another agent, you need to work offline, your organisation requires open source, or you already know your architecture and want a tidy path through each feature.&lt;/p&gt;

&lt;p&gt;Full comparison: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-spec-kit" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-spec-kit&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claudecode</category>
      <category>github</category>
      <category>programming</category>
    </item>
    <item>
      <title>Superpowers vs Halfcycle: a method you install, or one that keeps learning</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Thu, 05 Nov 2026 01:46:47 +0000</pubDate>
      <link>https://dev.to/halfcycle/superpowers-vs-halfcycle-a-method-you-install-or-one-that-keeps-learning-3432</link>
      <guid>https://dev.to/halfcycle/superpowers-vs-halfcycle-a-method-you-install-or-one-that-keeps-learning-3432</guid>
      <description>&lt;p&gt;&lt;em&gt;We make Halfcycle, so read this with that in mind. Superpowers is open source and well made; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Superpowers, by Jesse Vincent and Prime Radiant, is a set of skills that teaches your coding agent a development method. If you have used it, you know it changes how the agent behaves: it stops jumping straight to code.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Superpowers does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Design before code.&lt;/strong&gt; A written design for each piece of work, approved before building. Halfcycle does this too, and adds a product spec, the architecture and the phases above the per-component designs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Test-first, with evidence.&lt;/strong&gt; Halfcycle does this too: tests run before and after every change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A fresh reviewer per task&lt;/strong&gt;, and a final review of the whole branch. Halfcycle does this too, with each task reviewed twice by an agent that did not build it, and each finding recorded with its outcome.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The agent judges whether work is small or a project&lt;/strong&gt;, and you can overrule it. Halfcycle sizes it from the parts of your system a change touches and tells you why: a small change, a mini phase or a full phase.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Open, readable, many agents.&lt;/strong&gt; Sixteen coding agents named in its README. Halfcycle works with Claude Code and OpenAI Codex too, with OpenCode coming soon.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What Halfcycle adds
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;It learns from every project it runs on.&lt;/strong&gt; When any project goes wrong in a new way, the cause and the fix reach yours automatically. What travels is the shape of the problem, never your code, and we do not train on your work. Superpowers' README describes no learning across projects.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Served, not installed.&lt;/strong&gt; The method reaches your project one step at a time, so improvements arrive without you updating anything.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The running app gets tested.&lt;/strong&gt; At the end of each phase an AI agent clicks through the live app in a browser. Superpowers' README describes no testing of a running app.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A console.&lt;/strong&gt; Progress, phases, the system design, every agent and what it is building, and approvals recorded with who and when.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Risky actions are checked before they happen&lt;/strong&gt;: deleting unsaved work, rewriting history, reading credentials, publishing.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  When Superpowers is the better choice
&lt;/h2&gt;

&lt;p&gt;You want open source you can read and change, you work offline, or you use an agent other than Claude Code or Codex. All fair reasons.&lt;/p&gt;

&lt;p&gt;Full comparison: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-superpowers" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-superpowers&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claudecode</category>
      <category>productivity</category>
      <category>programming</category>
    </item>
    <item>
      <title>Emergent vs building it as your own code: planning, testing and what it is built with</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Thu, 05 Nov 2026 01:46:19 +0000</pubDate>
      <link>https://dev.to/halfcycle/emergent-vs-building-it-as-your-own-code-planning-testing-and-what-it-is-built-with-57a2</link>
      <guid>https://dev.to/halfcycle/emergent-vs-building-it-as-your-own-code-planning-testing-and-what-it-is-built-with-57a2</guid>
      <description>&lt;p&gt;&lt;em&gt;Halfcycle is a team of AI agents that plans, builds, checks and tests software inside Claude Code or OpenAI Codex. We make it, so read this with that in mind; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Emergent is an AI app builder: describe a web or mobile app in the browser, its agents build and test it, and it runs on Emergent's hosting with a database already set up.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Emergent does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Nothing to set up.&lt;/strong&gt; Hosting and a database come ready. Halfcycle does this too: you run one command and describe what you want, and it suggests a database and hosting that take minutes to set up, then sets them up as a step in the plan.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Testing built in&lt;/strong&gt;, and on its top plan a testing agent clicks through the app. Halfcycle does this too, on every project: tests run as it builds, and at the end of each phase an AI agent that built none of it clicks through the live app.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A plan before the build&lt;/strong&gt;, on its top plan: its newest builder (in beta) interviews you and writes a phased plan. Halfcycle does this too, whenever the work needs it, and writes the plan into your repository.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Web and mobile.&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where the difference is
&lt;/h2&gt;

&lt;p&gt;From Emergent's own site and docs, linked on the full page:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The tools.&lt;/strong&gt; React, Node.js or FastAPI, and MongoDB. Halfcycle picks whatever suits the project.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Review.&lt;/strong&gt; No separate review of the code is described. In Halfcycle, each piece is reviewed by an AI agent that did not build it, before it is added.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Where it runs.&lt;/strong&gt; Emergent's hosting, or your own cloud on its Enterprise plan. With Halfcycle, wherever you choose.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;How much process.&lt;/strong&gt; Emergent's plan decides which builder you get. Halfcycle sizes the process to each change and tells you why.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How to choose
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;A quick web or mobile app on hosting that is ready to go: Emergent.&lt;/li&gt;
&lt;li&gt;Software you own, planned and reviewed whatever its size, built with the right tools: Halfcycle.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Full comparison: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-emergent" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-emergent&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>nocode</category>
      <category>claudecode</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Spec-driven development with AI coding agents: what a spec has to do</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Tue, 03 Nov 2026 06:20:31 +0000</pubDate>
      <link>https://dev.to/halfcycle/spec-driven-development-with-ai-coding-agents-what-a-spec-has-to-do-294k</link>
      <guid>https://dev.to/halfcycle/spec-driven-development-with-ai-coding-agents-what-a-spec-has-to-do-294k</guid>
      <description>&lt;p&gt;&lt;em&gt;Halfcycle is a module that runs a five-layer build method inside your own Claude Code or OpenAI Codex (&lt;code&gt;npx halfcycle&lt;/code&gt;).&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Ask a coding agent for a feature in one sentence and you get a feature. It will be plausible, it will run, and it will contain a dozen decisions nobody made. Which users can see it. What happens when the list is empty. Whether the old endpoint still works. The agent did not skip those questions. It answered them, quietly, with guesses.&lt;/p&gt;

&lt;p&gt;Spec-driven development is the practice of making those decisions before the code exists and writing them down where the agent, and whoever reviews its work, can see them. The spec becomes the thing the code is checked against, not a summary written after.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqlwl1u0t3yg1cq9ugunw.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqlwl1u0t3yg1cq9ugunw.webp" alt="A one-line request, &amp;quot;Add team invites&amp;quot;, fanning out into ten decisions the agent made on its own: who can invite, how long a link lasts, what an expired link shows, what an empty team shows and more, each marked guessed" width="800" height="507"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Why agents made this matter again
&lt;/h2&gt;

&lt;p&gt;Writing down what to build before building it is older than most of the tools we build with. Teams moved away from heavy specification for good reasons. Documents went stale, and a person who met a vague requirement would usually walk over and ask.&lt;/p&gt;

&lt;p&gt;A coding agent rarely asks. Given a gap, it picks the most plausible answer and keeps going. It can build the wrong thing completely, with tests, in minutes, and the result looks finished. That last part is what makes it expensive, because nobody goes looking for a problem in work that looks done.&lt;/p&gt;

&lt;p&gt;The cost of a wrong decision has always grown with how late it is found. Settled in the spec, it costs a sentence. Caught when someone reads the spec, a paragraph. Found in code review, a task built again. Found after release, it can mean moving real users' data. Agents have not changed that curve. They have made it much easier to get a long way along it before anyone looks.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7ot6a8a1laggkn2syetn.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7ot6a8a1laggkn2syetn.webp" alt="Four bars rising from left to right: a wrong decision found in the spec costs a sentence, in spec review a paragraph, in code review a task rebuilt, after release real users' data moved. Not to scale" width="800" height="467"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Three things people mean by it
&lt;/h2&gt;

&lt;p&gt;The phrase covers three different practices, and a lot of argument about it comes from people meaning different ones.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Spec first.&lt;/strong&gt; A spec is written before the work, guides it, and is left behind once the feature ships. This is where most teams start, and it already removes most of the guessing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Spec kept.&lt;/strong&gt; The spec stays with the feature and changes when the feature changes, so the next piece of work starts from an accurate description instead of from reading the code. It costs more effort, and it pays back more the longer the product lives.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Spec as source.&lt;/strong&gt; People edit the spec and the code is regenerated from it. It is an appealing idea and still rare in practice, because a spec precise enough to generate from is close to being code itself.&lt;/p&gt;

&lt;p&gt;This piece is mostly about the first two. That is where the gains are today.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjoh7unsvofcwvwp43i99.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjoh7unsvofcwvwp43i99.webp" alt="Three columns. Spec first: the spec stays at version 1 while the code moves to version 3. Spec kept: spec and code both move to version 3 together. Spec as source: the spec is edited and the code is regenerated from it" width="799" height="493"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What goes in a spec that earns its keep
&lt;/h2&gt;

&lt;p&gt;A useful spec is short and specific. It answers four questions, and each one has its own way of going wrong.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fv2r6pxskvaygnqa834o6.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fv2r6pxskvaygnqa834o6.webp" alt="A spec page with four sections, purpose, done when, boundary and product rules, each linked to the question it answers" width="800" height="547"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  What is this for, and for whom?
&lt;/h3&gt;

&lt;p&gt;One or two sentences. If nobody can write them, the feature is not ready to build, and finding that out now is cheap. This is also the question most likely to show that two people wanted two different things, which is far better discovered here than in a demo.&lt;/p&gt;

&lt;h3&gt;
  
  
  What must be true when it is done?
&lt;/h3&gt;

&lt;p&gt;These are the acceptance criteria, and they are the heart of it. Each one should be checkable by someone who did not write it: "an empty list shows the invite button", not "handles empty states well". If a criterion cannot fail, it is not doing any work.&lt;/p&gt;

&lt;p&gt;A useful test: could someone who has never seen the code decide, in a minute, whether the criterion holds? If they would need to ask what it means, it needs another pass.&lt;/p&gt;

&lt;p&gt;Criteria are also the cheapest place to write down the unhappy paths. The expired link, the second click on a submit button, the user without permission, the list with nothing in it. Agents are good at the path where everything works. The rest is where the guesses live.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3m1f3gmu6fod7x54pj17.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3m1f3gmu6fod7x54pj17.webp" alt="Four vague criteria beside four checkable ones. &amp;quot;Handles empty states well&amp;quot; becomes &amp;quot;an empty team list shows the invite button&amp;quot;. &amp;quot;Errors are handled&amp;quot; becomes &amp;quot;an expired link says ask for a new invite&amp;quot;. &amp;quot;Only the right people can invite&amp;quot; becomes &amp;quot;a member who is not an owner sees no invite button&amp;quot;. &amp;quot;Fast&amp;quot; becomes &amp;quot;the team page loads in under two seconds on the test data&amp;quot;" width="800" height="520"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  What does it touch, and what does it leave alone?
&lt;/h3&gt;

&lt;p&gt;The parts of the system this change owns, the parts it depends on, and the things that are explicitly out of scope. Agents are generous. Without a boundary they tidy, refactor and improve their way into code nobody asked them to touch.&lt;/p&gt;

&lt;p&gt;The out-of-scope line is the most neglected one in most specs and the most useful one for an agent. "Bulk invites are out of scope" can save an afternoon of well-meant work that then has to be reviewed, tested and possibly removed.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkf0tjr3l0g9xazt61tmr.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkf0tjr3l0g9xazt61tmr.webp" alt="Three nested boxes. Inside, what the change owns: the team page, the invites table, the email sender. Around it, what it depends on: sign-in and the existing email templates. Outside, dashed, what is out of scope: bulk invites, other roles, changing the owner" width="800" height="553"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  What rules hold across the whole product?
&lt;/h3&gt;

&lt;p&gt;Some things are true everywhere: every money amount is stored in minor units, every page needs a signed-in user, nothing is deleted without a record. These belong in one place, referred to by every spec, so they are not restated slightly differently twenty times.&lt;/p&gt;

&lt;p&gt;Restated rules drift. One spec says pence, another says decimals, a third rounds to two places, and an agent reading any one of them builds something locally correct that disagrees with the feature next door.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0m44qhjbfwkicpe8hp39.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0m44qhjbfwkicpe8hp39.webp" alt="On the left, four feature specs each restating the money rule differently: pence, minor units, decimals, rounded to two places. On the right, one product rules box that all four specs refer to" width="800" height="520"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What one looks like
&lt;/h2&gt;

&lt;p&gt;Here is a small feature written out. It fits on one screen, and it is enough for an agent to build from and for someone else to check.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Feature: invite a teammate

For: workspace owners who want a colleague in the same workspace.

Done when:
1. An owner can enter an email address and send an invite.
2. The invitee gets one email with a link that works once, for seven days.
3. An expired or used link says "ask for a new invite", not an error page.
4. A member who is not an owner does not see the invite button.
5. Inviting someone who is already a member says so and sends nothing.
6. An empty team list shows the invite button and one line explaining it.

Owns: the team page, the invites table, the email sender.
Depends on: sign-in, the existing email templates.
Out of scope: bulk invites, roles other than member, changing the owner.

Product rules that apply: every page needs a signed-in user;
nothing is deleted without a record.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Notice what it leaves out. There are no file names, no function names and no instructions about how to write the code. Those are the agent's job, and they are what the reviewer checks against the criteria. A spec that dictates the implementation goes stale the first time someone finds a better one.&lt;/p&gt;

&lt;h2&gt;
  
  
  A spec sits inside a plan
&lt;/h2&gt;

&lt;p&gt;A feature spec answers "what does this feature do". It cannot answer "should this feature exist" or "how does it fit with the other eleven". Those questions live a level up.&lt;/p&gt;

&lt;p&gt;So spec-driven development, done properly, has layers. A product plan says what the product is for and what is in and out. An architecture says what the parts are and how they talk. A phase plan says which features ship together and in what order. Then each feature gets its spec. Skip the upper layers and every feature spec is locally sensible and globally inconsistent, which is a very common way for an AI-built product to fall apart around its fourth feature.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn0fy5z9tiwl9aodo7buv.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn0fy5z9tiwl9aodo7buv.webp" alt="Four stacked layers, product plan, architecture, phase plan and feature spec, with the code at the bottom built from the feature spec and checked back against both the spec and the phase plan" width="800" height="600"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The loop around a spec
&lt;/h2&gt;

&lt;p&gt;A spec is a decision written down. It only changes the outcome if things happen to it before and after the build.&lt;/p&gt;

&lt;p&gt;The decisions come first, one at a time, from the person who owns them. Then the spec is written, with its criteria and its boundary. Before any code, someone who did not write it reads it critically and asks "what happens when". Tests are written from the criteria and run once against no code at all, so they are seen to fail; a test that has never failed has never been shown to test anything. Then the build. Then a review of the work against the spec, by someone who did not build it. Then a check of the whole phase against the plan, including anything that was quietly dropped along the way.&lt;/p&gt;

&lt;p&gt;Whatever went wrong on the way round goes back into how the next spec is written. That last step is the one teams skip, and it is the reason their specs stop improving after the first month.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fd5ay2822m8737k0qbcsf.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fd5ay2822m8737k0qbcsf.webp" alt="A loop of seven steps: decide, write the spec, review the spec, tests from criteria, build, review the work, check the phase, with what was learned in the middle feeding the next spec" width="800" height="627"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Four ways specs fail
&lt;/h2&gt;

&lt;p&gt;Most teams that try this and give up hit one of these.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Nobody reads it critically before the build.&lt;/strong&gt; The person who wrote the spec, or the agent that drafted it, is the worst reviewer of it. Gaps are invisible to their author. A second reader with fresh eyes, asking "what happens when", finds the holes while they still cost a sentence to fix.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Nothing checks the code against it afterwards.&lt;/strong&gt; A spec with no check at the end is a wish. The acceptance criteria have to be run, ideally as tests written before the code, and the finished phase has to be compared with what the plan said it would deliver. Including the parts that were quietly dropped.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The same weight for every change.&lt;/strong&gt; A full spec for a copy fix is ceremony, and people stop following a process the week it wastes their time. A one-line spec for a payments change is negligence. The amount of planning has to fit the risk of the change, or the whole practice gets abandoned.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It lives apart from the work.&lt;/strong&gt; A spec in a wiki that the agent never sees is decoration. It has to be in front of the agent at the step where it matters, and in front of the reviewer when the work comes back.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb0tvyfbsrpggrrk22ltp.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb0tvyfbsrpggrrk22ltp.webp" alt="The seven steps of the loop in a row, with the spec review and the two checks at the end drawn as missing, the spec never reaching the build, and one bracket under the whole row for giving every change the same weight" width="800" height="467"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Sizing the spec to the change
&lt;/h2&gt;

&lt;p&gt;The third failure deserves more than a paragraph, because it is the one that kills the practice quietly.&lt;/p&gt;

&lt;p&gt;The deciding question is not how big a change is. It is what the change touches. A copy fix touches nothing shared, so its spec is one sentence and the check is looking at it. An ordinary feature touches a few parts, so it gets a spec with criteria and a boundary, a review before the build and a review after. A change that touches money, permissions or stored data gets the layers above it, a review of the spec, tests first, the build, a review, and a check of the whole phase.&lt;/p&gt;

&lt;p&gt;Size alone misleads in both directions. A one-line change to how refunds are rounded deserves more spec than a whole new settings page. And a "small" change that turns out to cross three parts of the system should move up a level the moment that becomes clear, not after it has been merged.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9vr9a2qw90rg8ql6h3g9.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9vr9a2qw90rg8ql6h3g9.webp" alt="Three rows. A copy fix: one sentence, then look at it. An ordinary feature: spec and criteria, review, build, review. A risky change touching money, permissions or stored data: plan layers, spec, review, tests first, build, review, phase check" width="800" height="467"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  When the code and the spec disagree
&lt;/h2&gt;

&lt;p&gt;Sooner or later the build finds something the spec got wrong, or said nothing about. There are two honest responses. Change the spec and say why, or change the code to match the spec.&lt;/p&gt;

&lt;p&gt;The third response is to leave both and move on, so the spec quietly stops describing the product. That is how specification documents earned their bad name, and it is avoidable. Updating the spec is part of finishing the task, not a chore for later, and the review of the work is the natural place to insist on it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw88n6oit5jlyhhntwf75.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw88n6oit5jlyhhntwf75.webp" alt="The build finds a gap. Two paths keep the spec true: change the spec and say why, or change the code to match. A third, dashed path, leave both, is labelled how specs earned their bad name" width="800" height="427"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How to judge a spec
&lt;/h2&gt;

&lt;p&gt;A quick way to read any spec, yours or an agent's, before it goes to the build.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Question&lt;/th&gt;
&lt;th&gt;Good sign&lt;/th&gt;
&lt;th&gt;Warning sign&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Purpose&lt;/td&gt;
&lt;td&gt;Two sentences and a named user&lt;/td&gt;
&lt;td&gt;"Improve the experience"&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Criteria&lt;/td&gt;
&lt;td&gt;Each one could fail, and someone else can check it&lt;/td&gt;
&lt;td&gt;"Works well", "handles errors"&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Unhappy paths&lt;/td&gt;
&lt;td&gt;Expired, duplicate and no-permission cases are written&lt;/td&gt;
&lt;td&gt;Only the path where everything works&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Boundary&lt;/td&gt;
&lt;td&gt;Owns, depends on and out of scope are all listed&lt;/td&gt;
&lt;td&gt;Nothing is out of scope&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Product rules&lt;/td&gt;
&lt;td&gt;Referred to by name&lt;/td&gt;
&lt;td&gt;Restated, slightly differently&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Implementation&lt;/td&gt;
&lt;td&gt;Left to the builder&lt;/td&gt;
&lt;td&gt;File and function names dictated&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Review&lt;/td&gt;
&lt;td&gt;Read by someone who did not write it&lt;/td&gt;
&lt;td&gt;Approved by its author&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;After the build&lt;/td&gt;
&lt;td&gt;Criteria run as tests, the phase checked against the plan&lt;/td&gt;
&lt;td&gt;"Looks done"&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Weight&lt;/td&gt;
&lt;td&gt;Fits what the change touches&lt;/td&gt;
&lt;td&gt;The same template for everything&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  What a spec cannot do alone
&lt;/h2&gt;

&lt;p&gt;Notice that three of those four failures are not about the spec at all. They are about review, testing, sizing and context: the other practices around a coding agent. That is the pattern with every one of these practices. A spec is necessary, and on its own it is not enough. Pair it with an independent reviewer, tests that run against its criteria, and a check at the end, and it starts to pay for itself.&lt;/p&gt;

&lt;p&gt;We wrote about that wider set of practices in &lt;a href="https://halfcycle.ai/writing/harness-engineering" rel="noopener noreferrer"&gt;harness engineering for coding agents&lt;/a&gt;. Spec-driven development is the part that decides what "correct" means. The rest is what holds the code to it.&lt;/p&gt;

&lt;h2&gt;
  
  
  How Halfcycle does it
&lt;/h2&gt;

&lt;p&gt;Halfcycle runs spec-driven development inside Claude Code or OpenAI Codex, with the layers and the checks already joined up.&lt;/p&gt;

&lt;p&gt;It starts above the feature. You are interviewed one decision at a time, and from your answers it writes the product plan, the architecture and the phases. Each feature then gets a spec with acceptance criteria and its boundaries, and the rules that hold across the product are written once and referred to.&lt;/p&gt;

&lt;p&gt;Before any code, an agent that did not write the spec reviews it. During the build, tests are written from the criteria and must fail before the code exists and pass after. Each task is reviewed by an agent that did not build it. At the end of the phase the whole goal is checked against the plan, and the delivered product is walked through, so a criterion that was missed shows up as missed rather than as done.&lt;/p&gt;

&lt;p&gt;The amount of all this depends on the change. Halfcycle decides how much process a change needs from what it touches, so a small fix takes a short path and a risky change gets the full treatment. You answer the questions that are genuinely yours, and you are told what comes next, so there is no order of steps to remember.&lt;/p&gt;

&lt;p&gt;And it gets better at specs over time. When a project implementation goes wrong because a spec missed something, both the cause and the fix are kept and reach every other project automatically. So most of those gaps never open on your project, and the ones that do come with the answer attached. What travels is the shape of the gap, never your code or your documents, and we do not train on anyone's work.&lt;/p&gt;

&lt;h2&gt;
  
  
  The honest limits
&lt;/h2&gt;

&lt;p&gt;Halfcycle's specs describe the change being built. It does not yet keep one always-current document of how the whole system behaves today; that picture lives in the plan, the architecture and the record of what each phase delivered. It also needs a connection, because the method is served rather than stored in your repository.&lt;/p&gt;

&lt;p&gt;And if your change is genuinely small, the right spec may be one sentence. Halfcycle will tell you so. The point of spec-driven development was never paperwork. It is deciding on purpose, before the agent decides for you.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Getting started&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx halfcycle
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Run that in the folder you want to work in, then open it in Claude Code or OpenAI Codex and say what you are building. Needs Node 20 or newer. There is nothing to learn first, and it tells you what is next when it is next.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://halfcycle.ai" rel="noopener noreferrer"&gt;halfcycle.ai&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claudecode</category>
      <category>productivity</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>Harness engineering for coding agents: what a working harness needs</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Tue, 03 Nov 2026 05:59:02 +0000</pubDate>
      <link>https://dev.to/halfcycle/harness-engineering-for-coding-agents-what-a-working-harness-needs-2ame</link>
      <guid>https://dev.to/halfcycle/harness-engineering-for-coding-agents-what-a-working-harness-needs-2ame</guid>
      <description>&lt;p&gt;&lt;em&gt;Halfcycle is a module that runs a five-layer build method inside your own Claude Code or OpenAI Codex (&lt;code&gt;npx halfcycle&lt;/code&gt;).&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;A coding agent is a model plus a harness. The model writes the code. The harness is everything around it: what the agent is told, what it is allowed to touch, what checks its work, what it remembers, and who decides it is finished.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuws1pgng58ajdmlop1il.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuws1pgng58ajdmlop1il.webp" alt="The model in the middle, surrounded by the seven parts of a harness joined in a loop: instructions sized to the step, a written plan, limits that block the action, checks after every edit, a reviewer that did not write it, coordinated agents, and memory of what went wrong" width="800" height="587"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Harness engineering is the practice of building that second part on purpose. The term caught on because teams kept noticing the same thing. Swap in a better model and the results improve a little. Change the harness and the results change a lot. On one public benchmark, the same model scored noticeably higher inside one harness than inside another, with nothing else different.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqj4yuyx15jvwjp6h2tlc.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqj4yuyx15jvwjp6h2tlc.webp" alt="Two levers on the same task: swapping in a better model moves the result a little, changing the harness moves it a lot" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;So the question for a team is no longer which model to use. It is what surrounds the model, and who maintains it. This piece goes through what a working harness is made of, part by part, what each part needs from the others, and how to tell a working harness from a pile of plugins.&lt;/p&gt;

&lt;h2&gt;
  
  
  The loop every harness runs
&lt;/h2&gt;

&lt;p&gt;Every coding agent, whatever it is called, runs the same loop. The harness assembles what the model sees. The model decides on one action: read a file, edit one, run a command, hand work to another agent. The harness carries the action out, or refuses it. The result goes back into what the model sees, and the loop goes round again until something decides the work is done.&lt;/p&gt;

&lt;p&gt;That last part is where most of the engineering lives. A model will happily declare victory. The harness is what decides whether it gets to.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fazdn7vxhyu0m9kj26jvf.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fazdn7vxhyu0m9kj26jvf.webp" alt="The agent loop: what the model sees, the model decides, a check before the action, the action runs, a check after, the result goes back. In the middle, done is decided by the plan and a fresh reviewer, not the model. Each step is labelled with the part of the harness that acts there" width="800" height="600"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Look at the loop and the seven parts fall out of it. Something has to choose what goes into the model's view each turn. Something has to say what the work is before the loop starts. Something has to sit between the model's decision and the action, and something after it. Something has to read the finished work with fresh eyes. When more than one loop is running, something has to keep them apart. And something has to carry what was learned in one run of the loop into the next.&lt;/p&gt;

&lt;h2&gt;
  
  
  The seven parts
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Instructions sized to the step
&lt;/h3&gt;

&lt;p&gt;The agent needs to know what you are building and what step it is on. It does not need your whole wiki pasted into every session. Too little context and it guesses. Too much and the important line is buried under the unimportant ones, and models pay less attention to the middle of a long context than to its ends.&lt;/p&gt;

&lt;p&gt;The usual failure is a single instruction file that grows a line every time something goes wrong, until it is thousands of words of rules the agent mostly skims. The fix is not a better file. It is serving the right slice at the right moment: the plan when planning, the feature's spec and the rules it must keep when building, the checklist when reviewing. This part is what most people now call context engineering.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdsh5ztaekm2h270jj6w9.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdsh5ztaekm2h270jj6w9.webp" alt="Two context windows. On the left, everything every time: a tall stack of rules with the one line that mattered buried in the middle. On the right, the slice for this step: the step, its spec and acceptance criteria, the rules it must keep, and what comes next" width="800" height="547"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  2. A written plan before any code
&lt;/h3&gt;

&lt;p&gt;What the product is for, how it is put together, what each feature must do, written down with acceptance criteria someone can check. This is spec-driven development. Without it the agent fills every gap with a plausible guess, and plausible guesses are expensive to find later, because the code around them looks finished.&lt;/p&gt;

&lt;p&gt;A plan an agent can build from has layers. The product plan says what is in and what is out. The architecture says what the parts are, how they talk, and which rules hold everywhere. The phase plan says which features ship together and in what order. Only then does a feature get its spec. Skip the upper layers and every feature spec is sensible on its own and inconsistent with the next one, which is a very common way for an AI-built product to fall apart around its fourth feature. We went deeper on this in &lt;a href="https://halfcycle.ai/writing/spec-driven-development" rel="noopener noreferrer"&gt;spec-driven development with AI coding agents&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fchbtgxh38hiylzz03xxe.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fchbtgxh38hiylzz03xxe.webp" alt="The plan in layers: product plan, architecture, phase plan and feature spec, each built from the one above, then the code. A dashed line runs back from the code: it is checked against the spec and the plan" width="800" height="600"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Limits that act before the mistake
&lt;/h3&gt;

&lt;p&gt;Some actions should simply not happen: editing outside the agreed area, deleting work that was never saved, rewriting shared history, reading credentials, publishing. A rule in a prompt is a request. The model weighs it against everything else in its context and, most of the time, complies. A hook that refuses the action is a limit. It runs outside the model, so it does not depend on the model remembering.&lt;/p&gt;

&lt;p&gt;The trade-off is false alarms. A limit that interrupts constantly gets switched off, and then it protects nothing. So a limit has to be tried against real traffic before it is trusted. When we replayed 68,843 real agent actions through Halfcycle's limits, they stopped to ask the person 12 times. This is the part people mean by guardrails.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F75qgml5sg1vn4flrbp2u.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F75qgml5sg1vn4flrbp2u.webp" alt="Two lanes. A rule in the prompt: the model reads the rule, weighs it with everything else, and the action usually does not run. A limit outside the model: the model decides, a hook checks the action before it runs, and the person is asked in plain words or the action is refused" width="800" height="427"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Checks that run on what was written
&lt;/h3&gt;

&lt;p&gt;Tests the agent did not get to mark as passing itself. Lints that were proven to work by breaking them on purpose once. Something that runs after each edit, not once at the end.&lt;/p&gt;

&lt;p&gt;Two habits separate checks that work from checks that only look as if they do. First, a test has to fail before the code exists and pass after it. A test that has never failed has never been shown to test anything, and agents are very good at writing tests that pass against whatever they just built. Second, every check should be seen failing on purpose before it is trusted. A lint that quietly stopped matching anything months ago reads exactly like a lint that finds nothing wrong.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiu1mx4u9or1uz8gra0t1.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiu1mx4u9or1uz8gra0t1.webp" alt="The order that proves a test works: write the test, run it and watch it fail, write the code, run it and watch it pass. Below, a check that has never been seen failing looks the same as one that finds nothing, so it is broken on purpose once before it is trusted" width="799" height="453"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  5. A reviewer who did not write the code
&lt;/h3&gt;

&lt;p&gt;The agent that wrote a change is the worst-placed reader of it, for the same reason a person is. It already believes the code does what it meant. A second agent with fresh context and no stake in the work finds things the first one walks past.&lt;/p&gt;

&lt;p&gt;Two details decide whether review earns its cost. The reviewer needs something to review against, which is the spec; without one it reviews style. And each finding needs an outcome. A finding that is listed and never answered is noise. Each one should end up fixed, declined with a reason, or deferred on purpose, and the work should not count as done while one is open. When two rounds of review fail on the same task, the right move is usually not a third attempt but a fresh look at why: the spec was wrong, the order was wrong, or the task was too big.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F966lfatn6lezlhr53c95.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F966lfatn6lezlhr53c95.webp" alt="On the left, the builder reviews its own work and concludes it looks right. On the right, a fresh reviewer with new context reads the change against the spec, and every finding ends as fixed, declined with a reason, or deferred on purpose. The work is done only when none is open" width="800" height="533"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  6. More than one agent, coordinated
&lt;/h3&gt;

&lt;p&gt;Larger work splits into tasks with dependencies between them. Some can run side by side, each in its own copy of the code so they do not collide. Something has to decide what runs next and put the pieces back together.&lt;/p&gt;

&lt;p&gt;The rule that matters most is a boring one: two tasks that change the same file must not run at the same time, and the plan should say so before anyone starts. The second is that each worker reports in a fixed shape, what it changed, what it checked and what it did not, so the coordinator merges facts rather than summaries. Done badly, multi-agent orchestration produces the same mess faster, and in several places at once.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1ls7nktpmfb060guh0pa.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1ls7nktpmfb060guh0pa.webp" alt="Tasks in three waves. Wave one runs the data model, the billing API and the settings page side by side, each in its own copy of the code. Wave two runs the invoices list and billing settings once their dependencies are done; billing settings waits for the settings page because both change the same file. Wave three merges and checks the whole phase. Each worker reports what changed, what it checked and what it did not" width="800" height="573"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  7. Memory that outlasts the session
&lt;/h3&gt;

&lt;p&gt;What went wrong last time, and what fixed it. Without this, every session starts as a new hire on their first morning.&lt;/p&gt;

&lt;p&gt;Memory has three reaches, and most setups stop at the first. Within a session, the context window is the memory, and it is gone when the session ends. Within a project, notes and a record of decisions carry over, so the agent does not re-argue what was settled last week. Across projects is the reach almost nobody has, and it is the one that compounds. We come back to it below.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9q9eaio0osajann3zdxt.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9q9eaio0osajann3zdxt.webp" alt="Three reaches of memory. In a session: the context window, gone when the session ends. In a project: decisions and notes, so nothing settled is argued again. Across projects: the cause and the fix from other projects, which most setups never reach" width="800" height="427"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Why one piece on its own does not hold
&lt;/h2&gt;

&lt;p&gt;Most writing on harness engineering covers one of these parts well. That is useful, and it is also where teams get stuck, because each part depends on the others.&lt;/p&gt;

&lt;p&gt;A reviewer with no spec has nothing to review against, so it reviews style. Checks with no plan test whatever the agent decided the feature was. Limits with no plan block the obvious accidents and none of the expensive ones. Orchestration with no independent review multiplies whatever the first agent got wrong across every worker. Memory with nothing feeding it stays empty.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fchk7q8mbm0r7f6l7j7ud.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fchk7q8mbm0r7f6l7j7ud.webp" alt="What each part needs from the others: a reviewer without a spec reviews style; checks without a plan test whatever the agent decided; limits without a plan block the obvious and miss the expensive; orchestration without review multiplies the first mistake; memory without checks and reviews feeding it stays empty" width="800" height="533"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The pieces are a system. Put three of them in place and you get some of the benefit and most of the maintenance.&lt;/p&gt;

&lt;p&gt;That maintenance is the part nobody budgets for. A harness is software. Its hooks need updating when the agent's tools change. Its instructions drift as the project grows. Its checks need testing themselves, or one day they quietly stop checking. Teams that build their own usually find the harness has become a second product with no owner.&lt;/p&gt;

&lt;h2&gt;
  
  
  One size fits nobody
&lt;/h2&gt;

&lt;p&gt;A harness that gives every change the same treatment fails in both directions. A full plan, spec and review cycle for a one-line copy fix is ceremony, and people stop following a process the week it wastes their time. A one-line note for a payments change is negligence.&lt;/p&gt;

&lt;p&gt;So a working harness sizes the process to the change, from what the change touches rather than from how it was described. In Halfcycle that comes out as three paths. A small change runs in one session and is reviewed by an agent that did not make it. A change across parts that fits one short spec runs as a mini phase. Anything larger is a full phase, with its plan, its specs and a check of the whole at the end. The session says which path it chose and why, and a small change that turns out to cross parts is moved up.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo15eyvmb3oa9i2z9s75h.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo15eyvmb3oa9i2z9s75h.webp" alt="Three paths for a change, chosen from what it touches. A small change, such as a copy fix, runs in one session and is reviewed by an agent that did not make it. A mini phase, such as a new field shown in two places, runs from one short spec. A full phase, such as a payments integration, gets the plan, specs, a parallel build and a check of the whole. A small change that turns out to cross parts is moved up" width="800" height="547"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;A folder of documents cannot do this, because it cannot tell a two-screen internal tool from a payments integration. It hands both the same ceremony.&lt;/p&gt;

&lt;h2&gt;
  
  
  The part a homemade harness cannot do
&lt;/h2&gt;

&lt;p&gt;There is one more property, and a team cannot build it alone however good they are.&lt;/p&gt;

&lt;p&gt;A harness built in-house learns from one team's mistakes. When a project implementation goes wrong, the useful things to keep are the cause and the fix. Keep only the cause and you have a warning. Keep both and you have an answer.&lt;/p&gt;

&lt;p&gt;If the harness is served instead of copied, both reach every other project automatically. From your side that gives two outcomes. Most problems of that kind never arrive on your project at all. The few that do arrive with the answer already attached, because someone else hit them first. And the list keeps growing, so a harness you copied last month is already behind.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fyyfyohpjpgrmcm9jc1op.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fyyfyohpjpgrmcm9jc1op.webp" alt="What a harness knows over time. A copied harness stays flat from the day it was copied. A served one steps up each time another project adds a cause and its fix. The two outcomes for your project: most of those problems never arrive, and the rest arrive with the answer attached" width="800" height="533"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;What travels back from a project is the shape of a problem, never the code or the documents. We do not train on anyone's work.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to judge a harness
&lt;/h2&gt;

&lt;p&gt;Whether you build one or adopt one, these questions separate a working harness from a collection of parts. Ask them of anything you are considering, ours included.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Part&lt;/th&gt;
&lt;th&gt;The question to ask&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Instructions&lt;/td&gt;
&lt;td&gt;Does the agent get the slice it needs for this step, or the same long file every time?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Plan&lt;/td&gt;
&lt;td&gt;Is there a product plan and an architecture above the feature specs, and is the code checked against them?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Limits&lt;/td&gt;
&lt;td&gt;Are risky actions stopped by something outside the model, and how often does it interrupt for nothing?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Checks&lt;/td&gt;
&lt;td&gt;Has each test been seen failing before it passed? Has each lint been seen catching something?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Review&lt;/td&gt;
&lt;td&gt;Is the reviewer a different agent from the builder, and does each finding end with an outcome?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Coordination&lt;/td&gt;
&lt;td&gt;Can two tasks that change the same file run at once? What does a worker report when it finishes?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Memory&lt;/td&gt;
&lt;td&gt;Does a lesson from last week reach today's session? Does a lesson from another project reach yours?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sizing&lt;/td&gt;
&lt;td&gt;Does a one-line fix get the same process as a payments change?&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Upkeep&lt;/td&gt;
&lt;td&gt;Who updates the harness when the agent's tools change, and how do you know its checks still work?&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  What Halfcycle is
&lt;/h2&gt;

&lt;p&gt;Halfcycle is a harness that ships with all seven parts already working together. You run one command in your project, open it in Claude Code or OpenAI Codex, and say what you are building.&lt;/p&gt;

&lt;p&gt;From there:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Planning comes first. You are interviewed one decision at a time, then the product plan, the architecture and each feature's spec are written, with acceptance criteria. A separate agent reviews the specs before any code exists.&lt;/li&gt;
&lt;li&gt;The agent gets only what the current step needs, and is told what comes next, so nobody has to remember the order.&lt;/li&gt;
&lt;li&gt;Risky actions are asked about in plain words before they happen, by hooks rather than polite instructions. Checks run after edits, and those checks were themselves tested by breaking them on purpose.&lt;/li&gt;
&lt;li&gt;Tests have to fail before the code is written and pass after, and Halfcycle runs them itself.&lt;/li&gt;
&lt;li&gt;Work is split into tasks with their dependencies. Up to eight builder and reviewer agents run at once, each in its own copy of the code, and two tasks that would change the same file are not run together.&lt;/li&gt;
&lt;li&gt;Each task is reviewed twice by an agent that did not build it, first against what was asked and then for quality, and each finding is recorded with its outcome. At the end of a phase, an agent that built none of it checks each acceptance criterion in the plan, and another walks the delivered product before the phase can close.&lt;/li&gt;
&lt;li&gt;The process is sized to the change: a small change, a mini phase or a full phase, and you are told which and why.&lt;/li&gt;
&lt;li&gt;What went wrong and what fixed it is remembered across sessions and, through the method Halfcycle serves, across projects.&lt;/li&gt;
&lt;li&gt;A console on the web and your phone shows the progress, the phases, the system design and every agent at work.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The result is less rework and less time spent steering. You describe what you want, answer the questions that are genuinely yours to answer, and the rest of the team around your coding agent is already there.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where it is not the right choice
&lt;/h2&gt;

&lt;p&gt;Some honest limits, since you will find them anyway.&lt;/p&gt;

&lt;p&gt;Halfcycle needs a connection, because the method is served and not stored in your repository. If you need to work fully offline, it is not for you today. It works with two coding agents, Claude Code and OpenAI Codex; OpenCode support is coming. You cannot yet plug your own hooks or presets into it. And if your work is one small script, a good set of instructions in a single file is probably all the harness you need.&lt;/p&gt;

&lt;p&gt;For anything bigger, the question is not whether you need a harness. You do. It is whether you want to build and maintain one, or start with one that is already working and keeps getting better.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Getting started&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx halfcycle
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Run that in the folder you want to work in, then open it in Claude Code or OpenAI Codex and say what you are building. Needs Node 20 or newer. There is nothing to learn first, and it tells you what is next when it is next.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://halfcycle.ai" rel="noopener noreferrer"&gt;halfcycle.ai&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>claudecode</category>
      <category>productivity</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>v0 or a whole project? Where Vercel's agent fits, and where it stops</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Sat, 31 Oct 2026 16:14:49 +0000</pubDate>
      <link>https://dev.to/halfcycle/v0-or-a-whole-project-where-vercels-agent-fits-and-where-it-stops-33j2</link>
      <guid>https://dev.to/halfcycle/v0-or-a-whole-project-where-vercels-agent-fits-and-where-it-stops-33j2</guid>
      <description>&lt;p&gt;&lt;em&gt;Halfcycle is a team of AI agents that plans, builds, checks and tests software inside Claude Code. We make it, so read this with that in mind; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;v0 is Vercel's AI agent for building web apps. You describe what you want in the browser, it writes the code with a fixed set of web tools, and publishes it to Vercel.&lt;/p&gt;

&lt;h2&gt;
  
  
  What v0 does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;It works the way developers work.&lt;/strong&gt; GitHub sync, a branch, a preview link per branch, a pull request when you publish. Halfcycle works in your repository too: each builder agent works on its own copy, and its work is added only after another agent has reviewed it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Polished interfaces&lt;/strong&gt;, with a visual design mode. Halfcycle has no visual editor.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Databases in one click&lt;/strong&gt; through Vercel's marketplace. Halfcycle recommends a database that fits your project, quick to set up if speed is what you need, and sets it up as a step in the plan.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan mode&lt;/strong&gt; on request. Halfcycle does this too, without you asking: it works out whether a change needs a plan and writes it into your repository.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where the difference is
&lt;/h2&gt;

&lt;p&gt;From v0's own docs, linked on the full page:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The tools.&lt;/strong&gt; Next.js, React, TypeScript, Tailwind CSS and shadcn/ui. Halfcycle picks whatever suits the project; our own run used Go and SQLite.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Checking.&lt;/strong&gt; v0 fixes errors it detects and can run tests in a sandbox; its docs describe no separate review of each change by another agent. Halfcycle reviews each piece with an AI agent that did not build it, and at the end of each phase another clicks through the finished app in a browser.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hosting.&lt;/strong&gt; v0 publishes to Vercel, and you can export and host elsewhere. Halfcycle leaves the code with you to put live wherever you choose.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How to choose
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;A web interface or a Next.js app, especially if you are on Vercel already: v0.&lt;/li&gt;
&lt;li&gt;A whole project with a backend, services and rules, built with whatever fits: Halfcycle.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Full comparison: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-v0" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-v0&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>nextjs</category>
      <category>claudecode</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Bolt builds it fast. Its docs say where it should stay</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Sat, 31 Oct 2026 16:14:25 +0000</pubDate>
      <link>https://dev.to/halfcycle/bolt-builds-it-fast-its-docs-say-where-it-should-stay-1804</link>
      <guid>https://dev.to/halfcycle/bolt-builds-it-fast-its-docs-say-where-it-should-stay-1804</guid>
      <description>&lt;p&gt;&lt;em&gt;Halfcycle is a team of AI agents that plans, builds, checks and tests software inside Claude Code. We make it, so read this with that in mind; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Bolt, from StackBlitz, is one of the quickest ways from a chat to a running app. You describe what you want in the browser and it builds websites, web apps and mobile apps, with hosting, a database and logins from Bolt Cloud.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Bolt does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Fast from chat to running app&lt;/strong&gt;, with no other accounts to open. Halfcycle can be quick too: ask for a quick prototype and it builds one, suggesting a database and hosting that take minutes to set up.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Easy to take the code.&lt;/strong&gt; Download a ZIP, or save every working change to GitHub. Halfcycle does this too: the code is in your own folder from the first line.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Existing projects.&lt;/strong&gt; Import a GitHub repository as a new project. Halfcycle reads the code you have too, and carries on from there.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan mode.&lt;/strong&gt; Talk the project through before anything changes. Halfcycle does this too, without you asking: it works out whether a change needs a plan and writes it into your repository.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where the difference is
&lt;/h2&gt;

&lt;p&gt;From Bolt's own docs, linked on the full page:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Where it should live.&lt;/strong&gt; Bolt hosting is the default, and its docs say a project with a database or backend should stay there.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Security.&lt;/strong&gt; Bolt checks when you publish, with a full audit on paid plans. Halfcycle plans security in from the start: the rules about who can sign in and see what are part of the plan, and each piece is reviewed against them before it is added.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Review.&lt;/strong&gt; Its docs describe no separate review of each change by another agent. In Halfcycle, an AI agent that did not build a piece reviews it, and at the end of each phase another clicks through the finished app in a browser.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How to choose
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;A quick site or app you are happy to keep on Bolt Cloud: Bolt.&lt;/li&gt;
&lt;li&gt;Something with a backend you need to own and host yourself: Halfcycle, which leaves ordinary code in your repository.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Full comparison: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-bolt" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-bolt&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>nocode</category>
      <category>claudecode</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Replit Agent tests its own app. Who reviews the code?</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Sat, 31 Oct 2026 03:11:41 +0000</pubDate>
      <link>https://dev.to/halfcycle/replit-agent-tests-its-own-app-who-reviews-the-code-1dph</link>
      <guid>https://dev.to/halfcycle/replit-agent-tests-its-own-app-who-reviews-the-code-1dph</guid>
      <description>&lt;p&gt;&lt;em&gt;Halfcycle is a team of AI agents that plans, builds, checks and tests software inside Claude Code. We make it, so read this with that in mind; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Replit Agent is impressive. Describe an idea and it sets up the database and logins, builds the app, opens it in a real browser, clicks through it and fixes what it finds, then publishes it. All in one place.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Replit does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Everything in one place.&lt;/strong&gt; Writing, running, data, logins and publishing. Halfcycle does not host apps; it recommends where yours should run and sets that up as a step in the plan.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It tries the app itself.&lt;/strong&gt; Halfcycle does this too: when a phase is finished, an AI agent that built none of it clicks through the live app in a browser and sends back what it finds.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Plan mode.&lt;/strong&gt; It talks the work through and suggests a task list without touching files. Halfcycle does this too, without you asking: it works out whether a change needs a plan and writes it into your repository.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Existing projects.&lt;/strong&gt; It imports GitHub repositories. Halfcycle reads the code you have too, and carries on from there.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where the difference is
&lt;/h2&gt;

&lt;p&gt;From Replit's own docs, linked on the full page:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Review.&lt;/strong&gt; Its docs describe no separate review of the code by another agent. In Halfcycle, each piece is reviewed by an AI agent that did not build it before it is added.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The plan.&lt;/strong&gt; Replit's plan appears in the chat. Halfcycle writes the product spec, the architecture and a design for each component into your repository, where every later agent works from it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Logins.&lt;/strong&gt; With Replit Auth, your users sign in with Replit accounts on a Replit-branded page. With Halfcycle, logins are whatever suits your project and your users.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Where it runs.&lt;/strong&gt; Replit apps are published on Replit, billed by use. Halfcycle leaves the code with you to put live where you choose.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How to choose
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;An idea you want running in one place, today, and you are happy for it to live on Replit: Replit.&lt;/li&gt;
&lt;li&gt;Software you own, reviewed piece by piece and hosted where you choose: Halfcycle. It can have a first version up today too.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Full comparison: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-replit" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-replit&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>replit</category>
      <category>claudecode</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Lovable or your own code? What changes when the app has to last</title>
      <dc:creator>Halfcycle</dc:creator>
      <pubDate>Sat, 31 Oct 2026 03:05:32 +0000</pubDate>
      <link>https://dev.to/halfcycle/lovable-or-your-own-code-what-changes-when-the-app-has-to-last-3pk</link>
      <guid>https://dev.to/halfcycle/lovable-or-your-own-code-what-changes-when-the-app-has-to-last-3pk</guid>
      <description>&lt;p&gt;&lt;em&gt;Halfcycle is a team of AI agents that plans, builds, checks and tests software inside Claude Code. We make it, so read this with that in mind; the full comparison, with every source, is on our site.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Lovable is one of the best AI app builders around. You describe a web app in the browser and it builds it, with a database, logins and hosting on its own backend. The question worth asking before you start is not how quickly it appears. Both can have a first version working today. It is what the app depends on once it is running.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Lovable does well
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The code is yours.&lt;/strong&gt; Its docs say so, and two-way GitHub sync is on every plan. Halfcycle does this too: the code is in your own folder from the first line.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A plan before big changes.&lt;/strong&gt; Plan mode writes a plan you approve before code changes. Halfcycle does this too, without you asking: it works out whether a change needs a plan, and when it does, writes the product spec, the architecture and a design for each part into your repository.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Nothing to set up.&lt;/strong&gt; A database, logins and hosting come built in. Halfcycle does this too: you run one command and describe what you want, and it suggests a database, logins and hosting that take minutes to set up, then sets them up as a step in the plan.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where the difference is
&lt;/h2&gt;

&lt;p&gt;From Lovable's own docs, linked on the full page:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Where the app lives.&lt;/strong&gt; The code can go elsewhere, but the built-in backend, AI features and connectors keep running through Lovable until you replace them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;What it is built with.&lt;/strong&gt; Lovable chooses the tools; its docs say it does not offer a choice of framework or database. Halfcycle picks what suits the project.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Existing code.&lt;/strong&gt; A ZIP upload is rebuilt on Lovable's backend, and GitHub sync cannot connect an existing repository. Halfcycle reads the code you have and carries on from there.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Checking.&lt;/strong&gt; Lovable runs security scans. Halfcycle plans security in from the start: who can see what is written down once, and each piece is reviewed against it by an AI agent that did not build it, before it is added. At the end of each phase another AI agent clicks through the finished app in a browser.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How to choose
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;A quick app you are happy to keep on Lovable's backend: Lovable.&lt;/li&gt;
&lt;li&gt;Software you need to own, host where you choose and build on for years: Halfcycle, which runs in Claude Code and leaves ordinary code in your repository.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Full comparison, table, FAQ and sources: &lt;a href="https://halfcycle.ai/compare/halfcycle-vs-lovable" rel="noopener noreferrer"&gt;https://halfcycle.ai/compare/halfcycle-vs-lovable&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>nocode</category>
      <category>claudecode</category>
      <category>webdev</category>
    </item>
  </channel>
</rss>
