Where coding agents go wrong, and how Railspike helps
You ask an agent to fix a CSV export. It rewrites the export helper, adds a dependency you ruled out, and says "done" after testing the helper in isolation. You open the app and the Download button still fails. That's several different problems in one diff.
Tang and colleagues studied 20,574 real-world coding-agent sessions. Among the episodes where developers visibly pushed back, the most frequent symptoms were ignored constraints (38%), misunderstood intent (27%), and inaccurate status reports (23%). In Stack Overflow's 2025 survey, 66% of respondents to the AI-frustrations question reported dealing with almost-correct answers, and 45% reported that debugging AI-generated code took more time. Coding-agent study, Table 3 · Stack Overflow survey
Railspike is a set of Markdown instructions for your existing coding agent. Its staged workflow runs through optional assessment, a feature description, a development plan, and implementation. You can edit the planning files in the repo and explicitly approve each step before the agent proceeds.
"It ignored a constraint I gave it"
Railspike asks the agent to read the repo's instructions and carry the approved boundaries into its plan. If the rule is "use the existing CSV writer and add no dependency," you can see it in the plan before code changes. If the agent later finds that completing the task requires changing the approved scope, it has to bring that change back for approval. The diff review checks the work against the same boundaries.
"It built the wrong thing"
The feature description makes the intended behavior concrete before you approve it. For an export, that might mean downloading the currently filtered rows through the existing button, with column order preserved. If the request has several plausible interpretations, the optional assessment gives you a place to compare them or combine parts of proposed approaches while the decision is still cheap to change.
"It said it was done, but I still can't use it"
The development plan records the completion checks up front. During implementation the agent records what it ran, what passed, and what is still blocked or pending. A unit test for CSV serialization answers a different question from downloading the correct file through the app. Railspike asks for verification through the normal entry point and keeps implementation, merge, and release status distinct.
"The code is almost right, and I'm doing the debugging"
The plan breaks staged work into pieces with their own checks. Implementation happens on a feature branch, with stage-scoped commits and a summary of the changes and results. When a later check exposes a regression, you have smaller diffs and a record of what was exercised. The shared implementation instructions also call for reproducing reported failures in the relevant environment and checking retry or recovery where the task requires it.
"It guessed how the repo works"
Railspike asks the agent to inspect the actual call paths, find the existing components and contracts, and record what it will reuse or extend. For the export, that could mean finding where the UI applies filters and where the server already serializes rows. The plan gives you a chance to catch a bad assumption with source paths in front of you.
"I asked for a fix and got a refactor"
The approved outcome and file boundaries give you something concrete to compare with the diff. The agent checks each staged commit for unrelated changes. If it spots an opportunity to replace the whole export subsystem, that can be discussed separately while the original fix stays reviewable.
"I opened a new session and had to explain everything again"
The approved requirements, plan, and implementation summary live in the repo. On resumption, Railspike asks the agent to verify the approved files and commits and recover the current stage. The next session can pick up from the decision you actually made and the checks that still need to run.
"The agent ran the wrong command or checked the wrong environment"
Railspike can surface this through the plan and verification record. Name the target environment, record the command and its result, and require evidence from the environment where the problem occurs. The workflow still depends on the agent and reviewer checking that the command targeted the right place.
The tradeoff is time spent reviewing plans. Railspike also has a one-shot mode for a bounded task you authorize upfront. It keeps scope, decisions, and verification in one evolving record and skips the intermediate planning approvals. Both modes rely on the agent following written instructions. Tool permissions and CI checks are separate controls. Railspike workflow and modes · Shared implementation standards
Which of these costs you the most time with coding agents? If you've tried Railspike, where did it save a round of rework, and where did it add one?