You can build it, but should you?
Todd M. Gureckis · · 4 minutes to readCoding agents have lowered the cost of writing new software so dramatically that they force an old engineering question into a new light: when is it worth building something from scratch versus building on an existing framework?
For many of the smaller, self-contained coding tasks that come up in research projects, there is a temptation to just point an agent at the problem and let it reimplement everything from the ground up. Take online behavioral experiments. In the past, frameworks like jsPsych were essential for research progress because they offered standardized, human-friendly APIs. They insulated scientists from annoying JavaScript quirks, cross-browser differences, and the tedious plumbing of running a study and saving data reliably.
Today, that argument can feel less pressing. If you don't have to wrestle with JavaScript yourself, why spend time learning a framework's abstractions and conventions? You can just point a coding agent at your experimental design and say, "make a webpage for me that runs this task." A few minutes later, you have a working prototype.[1]
This extends to many aspects of the cognitive modeling pipeline as well. For example, why reuse a library for Markov Chain Monte Carlo (MCMC) sampling when a coding agent could whip one up for you in a few minutes? In doing work on other projects I've seen agents go off and rebuild entire packages of an existing open-source project in a different language just to reconstruct a single graph.
There is no denying that this is practical—and for quick throwaway demos or exploratory scripts, it can be genuinely liberating. Still, I think scientists in particular should be hesitant to treat agentic reimplementation as the default way of doing science.
Bespoke code breaks in a million small ways
One immediate problem with everyone rolling their own one-off software is that it precludes common workflows and shared, debuggable pipelines.
Good research frameworks don't just save keystrokes; they encode years of hard-won lessons about the ways experiments fail in the wild. Participants hit the browser back button, refresh mid-trial, lose their internet connection, or open the task on an unexpected screen size. Subtle timing bugs, state management glitches, and data-logging edge cases only surface after thousands of runs.
When everyone uses an agent to generate their own bespoke task from scratch, everything can break in millions of small, idiosyncratic ways. A bug in your custom data-saving logic or randomization code won't be caught by the next lab running a similar study. Reviewers have to audit an unfamiliar codebase from line one just to understand how the data were collected.
One argument I can imagine is that agents will do all this reviewing, auditing, and bug tracking for us. That might be true in a few years, but it's still the case that there is a real savings in fixing bugs once and for all, for everyone. It's a waste of time and energy if people don't use standard workflows, even if you assume that the code is neither generated nor reviewed by humans.
Software abstraction still matters
Underlying the impulse to reimplement everything is a subtle assumption that coding agents have made software abstraction obsolete. I don't think that's right.
Yes, you can have an agent design and implement the layout, trial logic, and data pipeline for your task interface. Taken to its logical conclusion, though, why stop there? Why not have the agent implement the web server for you, too? Or the underlying database? Or the operating system underneath?
Nobody is rushing to have a coding agent write a fresh Linux kernel or database engine for every cognitive science study. Even in the age of agentic coding, choosing, and building upon established abstraction layers remains essential. We rely on those layers because they compress collective engineering effort into stable foundations that let us spend our attention on the scientific questions that actually matter.
For science especially, shared abstractions bring compounding benefits: interoperability across labs, more human eyes and peer reviewers who can actually read and evaluate the code, and both human and AI coding effort focused on hardening the same tools rather than solving the same baseline problems over and over again.
There is also an educational dimension to this, especially for beginners. Learning what abstraction layers are available—and how to use them effectively while guiding your own projects—encourages newer programmers to start learning how software systems are actually architected. More experienced programmers already carry that mental model around with them, so they know where the boundaries ought to be even when working with an agent. If you reduce everything down to control through prompts, you take away that learning opportunity from inexperienced programmers who need it most.
Building up, not standing still
Finally, there is an ethical and community dimension to this. We have a responsibility to give back to the open-source ecosystem that makes our work possible. When generating code feels nearly free, it is easy to imagine there is less reason to share tools or contribute upstream—after all, if someone else needs something similar, they can just prompt their own agent to build a version at relatively low cost.
I think that's a mistake. The goal of scientific infrastructure isn't to let everyone cheaply re-derive the current status quo in private. We want to build up, not get stuck recreating the same baseline capabilities over and over. Real progress still accrues to scientific problems where many people—and now their agents—collectively work on raising the floor and strengthening shared abstractions.
If anything, I see agentic coding as creating the opposite opportunity for open-source science. In the past, plenty of researchers had useful ideas, plugins, or fixes they could have contributed to shared tools, but held back because of annoying technical barriers: learning GitHub community standards, navigating a large unfamiliar codebase, writing thorough tests, or bringing research code up to production-grade quality. Coding agents lower those barriers substantially. It is far easier now to turn something you built for your own project into a clean, well-documented contribution that helps everyone else.
Just because you can have an agent build something from scratch doesn't mean you should. Let's keep building—in the open and collectively.
I'm seeing this more and more in student projects, which is perhaps why it felt worth writing about. ↩︎