My job as a solo developer used to be a relentless grind. I would write hundreds of lines of Python code a day, turning out decent packages and tools. But I was constantly racing the clock. I have a vivid imagination and a notebook full of ideas for high-value data tools, but I’ve always been behind. The time I spent on the core work meant I often cut corners on documentation and best practices. It was a trade-off I had to make, even though I knew a one-person team can’t afford to build a weak foundation.
Then, everything changed.
I started leveraging AI coding tools like Copilot, and not long after, Antigravity. In a matter of weeks, my role transformed. I’m no longer a programmer; I’m an agent supervisor. I barely write any code myself. Initially, I perused and reviewed some of the agent-generated code. But I soon realized that, more often than not, the agents produced something better than my own (cleaner, faster, and more idiomatic).
My focus shifted from writing code to ensuring that all the tests pass and that the agents are building what I intended. My productivity hasn’t just increased; it’s gone up by a factor of 10 or 20. I can now produce in a short time what would have taken me days or weeks. For someone who is essentially a one-person team, this is a significant boon. That dream of finally producing the myriad of high-value data tools I had in mind is now slowly becoming a reality.
The Quality Dividend: Building on Solid Ground
The greatest benefit of working with AI agents isn’t just the speed, but the dramatic improvement in the quality and stability of my output.
When I was the one doing all the coding, a deep dive into best practices often got sidelined due to time and resource constraints or simply a lack of personal interest. Now, the agents handle the first pass of the code, freeing me up to focus on the structure, testing, and compliance. I’ve integrated a powerful stack of quality tools that I would never have found the time or inclination to implement before:
Ruff and Mypy: These are now standard in my stack. Ruff ensures my code aligns with the latest best practices and style guides, making it instantly more readable and maintainable. Mypy minimizes potential runtime issues by checking type hints, which is crucial for building robust data pipelines.
Sphinx Documentation: My source code and documentation are kept up to date almost automatically. A core principle of high-value data is good documentation, and the agents make this a seamless part of the development process.
Roborev and GitHub CI/CD: I added Roborev to double-check my commits and ensure I maintain a clean, reliable code history. I’ve also strengthened my GitHub Actions for Continuous Integration (CI) and Continuous Deployment (CD). This full-stack quality assurance process ensures that every tool I release is reliable.
To enable all this, all my projects include an AGENT.md file that provides guidance to my AI helpers (see my related article). This document serves as the central rulebook for my AI collaborators, detailing tailored instructions, constraints, and principles. It ensures all AI contributions, from code to architecture, are consistent and aligned with project goals, my personal style, and standards. I detail its structure and effective prompts elsewhere.
This level of rigor is a small financial investment—Copilot is free for open-source developers, and I only subscribe to one professional AI service—but the return on investment is priceless in terms of product quality and my peace of mind.
Beyond Syntax: The FAIR Data Connection
As a technologist with a background in high-value data management and metadata standards, I see the AI agent revolution through a specific lens: the creation of machine-actionable digital knowledge. The ability to produce high-quality, well-tested, and fully-documented code isn’t an end in itself; it’s the necessary foundation for delivering on a greater vision.
This vision is anchored in the FAIR data principles: making data Findable, Accessible, Interoperable, and Reusable. For data to truly be high-value and machine-actionable, the tools and APIs used to manage and serve it must be:
Well-Tested: If the code driving data and metadata processing, or the APIs, is unreliable, the data is unusable. The agent-driven test-driven development (TDD) approach, where agents are excellent at writing test cases (and finding a few you missed), ensures robustness.
Well-Documented: Machine-actionable knowledge requires clear, standardized metadata and API documentation. The AI agents’ ability to generate and maintain documentation alongside the code ensures that other developers and machines can easily understand and connect to my data services.
Compliant: Using tools like Ruff and Mypy ensures the code is clean, consistent, and adheres to standards. This consistency is the core of Interoperability. A machine needs to rely on predictable interfaces.
The time AI agents save me on syntax and boilerplate coding is directly reinvested in the high-level design and data architecture—the truly intellectual work that ensures my data tools are not just functional but also contribute to a globally connected, machine-readable knowledge base. The end game of technology, as I see it, is not the code itself but the creation of data that other applications and researchers can use to drive positive change.
The New Developer Skillset: From Coder to Architect
Yes, there is a slight learning curve involved in becoming an “agent supervisor,” because it requires a fundamental change in how you approach work. For me, this shift has been a progression, and I believe it’s the direction most senior developers will move in the near future.
We are moving up a layer of abstraction. We’ve seen this happen before in programming: we went from writing in assembly language to higher-level languages like C and Fortran, and then to compilers and interpreters that made our lives easier. AI agents represent a similar leap in abstraction today.
This new workflow empowers the developer to focus on:
Creativity and Imagination: The human role remains the master of problem definition. You define the solution, the architecture, and the high-level logic. The agents execute the syntax.
Architecture and Glue-Code: My time is now spent designing the overall system, defining the data models, and making sure the various generated components—whether a Rust tool or a web UI—fit together perfectly.
As an anecdote, I’ve recently created small tools in Rust without having a deep, intimate knowledge of its intricacies. I can generate a website’s UI without getting bogged down in the endless specifics of CSS, JavaScript, or HTML. The agents handle the syntax, and I focus on the user experience and the data flow.
For new or young developers, learning to write code will remain critical; understanding how the machine works is still important. But AI can assist here, too, by acting as an immediate reviewer, mentor, and guide, teaching them best practices from the start.
The True End Game
What excites me most about this transition is the immediate, tangible progress toward my original vision: better data for a better world.
The goal is not to be a master of esoteric programming languages or to churn out code. The true measure of success is the actual positive impact and outcomes my data tools have on society—whether it’s helping researchers, improving public access to information, or enabling machine intelligence to tackle global problems.
My ability to deliver on this vision has increased dramatically. By embracing AI agents, I have found a path to prioritize the vision of FAIR data and machine-actionable knowledge, moving beyond the mechanics of programming to focus on the product’s purpose. The AI agent is not a replacement for the human mind; it’s the compiler for human creativity.
