The Developer’s Craft When AI Writes the Code

Wes McKinney’s email archive, Ritchie Vink’s Polars and David Heinemeier Hansson’s changeable computer reveal how developers learn, collaborate and choose what to delegate to coding agents.
Painted scene of two men at retro computer terminals in a vast dark hall: one, chin in hand, watches punched cards and charts swirl past; the other grins and reaches toward a stream of balloons, gummy bears, fantasy creatures and a mechanical spider.

In March 2026, Atlassian announced plans to cut about 1,600 jobs, roughly a tenth of its workforce. The company said the cuts would fund further investment in AI and enterprise sales and improve its finances. It said AI was changing the skills and number of roles it needed in some areas, while rejecting “AI replaces people” as its approach.

If agents can take on much of the coding, what happens to the need for developers, and to the work they do each day?

To understand that change, we look at what makes a software developer. We trace how developers acquire knowledge and judgment through practice and collaboration. That experience shapes how they recognize a problem and decide what a useful solution would look like. Writing code belongs to a wider task: deciding what software should do and finding a way to make it work.

We then examine how coding agents change the division of that work. We consider what becomes possible when developers can delegate more of the implementation, and how they adapt their own habits in response. We focus on the decisions they still make, how they assess the results and what it means to take responsibility for software an agent helped build.

McKinney wants his own archive

Wes McKinney wanted to find the documents he had already received. As an angel investor, he often needed old email attachments for his accountant. He had not filed them as they arrived, and searching Gmail meant working through results that seemed increasingly unrelated to what he was looking for. By his count, twenty years of correspondence contained more than 150,000 attachments.

He wanted the archive itself. For years, he had imagined keeping his messages on his own computer, where he could search them quickly and use a local language model without handing the collection to another company. A new interface to Gmail would leave him dependent on Gmail’s service. He wanted to be able to retrieve an old document even after removing the remote copy.

In February 2026, McKinney announced msgvault, a project he had spent the previous two months building with coding agents. It downloaded his mail, kept attachments locally and let him search through a terminal interface. He used it daily. It was also alpha software, with bugs and changes still to come.

The program was written in Go. A fortnight earlier, McKinney had described his new projects this way: “I have been building a lot of new software in Go. Except that I’ve never actually written a line of Go in my life.”

For the creator of pandas, building outside his familiar language was hardly new. He had spent years learning other languages and working with other developers to make the software he wanted possible.

McKinney learns to build beneath the application

McKinney’s account of his early work is unusually frank. He started pandas in 2008, largely during nights and weekends, without much knowledge of software engineering or Python’s scientific computing tools. “My code was ugly and slow,” he wrote in a 2017 retrospective. He learned while building, and from other people.

Five years after starting pandas, he and his longtime collaborator Chang She founded DataPad. They were building a visual analytics application and wanted to use the growing Python data stack underneath it. But the application’s queries were not responsive enough with pandas, particularly in their cloud setting. McKinney was now trying to build a product on the library he had created, and encountering its limits.

His response was to reduce the problem. He removed much of pandas’ feature set and built a smaller implementation called Badger, using compact, immutable columns that kept related values close together in memory. Much of the code was C. This was also when he began serious C development; C++ followed in 2015. The low-level expertise was something he acquired along the way.

Badger helped him investigate faster data processing, but he did not want to keep developing that particular codebase. After Cloudera acquired DataPad in 2014, he considered releasing it. He remembered too many C macros and a substantial cleanup ahead. Publishing it would create expectations among pandas users, while he wanted a replacement he could keep improving for years. He shelved the prototype.

At Cloudera, McKinney could learn from people building databases and large-scale storage systems. Trying to connect Python to their work exposed a recurring expense: moving a table between systems often meant reconstructing its contents in another representation. He wanted a common columnar foundation that could handle strings and nested data as well as numbers.

Julien Le Dem was approaching the problem through Parquet, the file format whose community was discussing an in-memory counterpart. In his later account, Le Dem recalls recognizing how much their proposed representation resembled work already done by Apache Drill. He had helped Drill’s developers work with Parquet. He brought them into the conversation.

The collaboration gave McKinney something he could not get by cleaning up Badger alone: other projects working toward the same agreement about data. The group adapted Drill’s Java vector code to a shared specification, and McKinney began a C++ implementation. Arrow took shape around those joint requirements. Le Dem’s satisfaction, in his retrospective, comes partly from building relationships with people who would not normally work in the same company.

TECHNICAL NOTE

From rebuilds to zero copy

Arrow specifies how columns occupy memory, so different libraries can interpret the same layout. Parquet serves storage and retrieval; Arrow addresses processing and exchange. A common layout lets a receiving library avoid rebuilding each value in its own representation.

In 2017, Bryan Cutler described the cost of moving a table from Spark toPandas(). Spark gathered rows, serialized each into Python’s pickle format and sent them to a separate Python process. There, Python created a list of tuples; pandas then walked through those values to construct a DataFrame. These intermediate representations cost time and memory before the analysis began.

Arrow’s designers wanted tools to agree on how they arranged data in memory. The specification groups values by column and defines how to represent them and describe their types. With that agreement, a receiving tool knows how to interpret the bytes already present. Developers can build different libraries around the same representation, reducing the need to translate values at each handoff.

Spark’s improved path built Arrow columns in the JVM and sent them to Python, avoiding pickle and the intermediate tuple list. Where representations matched, Python could reuse the data bytes when constructing pandas objects. That reuse is called zero-copy. It saves copying the values; libraries may still create metadata and wrapper objects. Preparing Arrow data and converting incompatible representations, such as some missing values, still require work.

Within one process, libraries can share pointers to compatible Arrow data. Separate processes can share memory too. With memory mapping (mmap), an R process and a Python process can read the same uncompressed Arrow file through memory shared by the operating system. Over a socket, the bytes still have to travel, although a compatible receiver can use the received data without converting it again.

Two paths compare historical Spark-to-pandas conversion. Both transfer data from JVM to Python. The row/pickle path serializes rows, rebuilds tuples and value objects, then scans them into new column arrays. The Arrow path prepares and transfers column buffers with metadata, then reuses compatible received buffers through a pandas wrapper. Both end in a usable pandas table.
Spark-to-pandas conversion, as described in 2017: Arrow avoids rebuilding rows as Python tuples and value objects. Data still travels between processes; zero-copy applies only when pandas can reuse compatible received buffers. The diagram compares steps, not measured speeds.

McKinney’s goal required more than agreement on a format. Looking back at late 2015, he recalled having little more than Markdown specification documents on the Python side. By the time he wrote his retrospective, he had spent almost two years turning those documents into usable software. The route from an unresponsive application to a shared foundation involved learning, abandoning a prototype and persuading separate projects to cooperate.

Vink builds a tool and learns what it needs

Ritchie Vink needed to join tables in Rust, found no DataFrame library there to do the job, and built a simple structure on Arrow. His first version was slower than pandas. He kept working on it; a Python interface followed.

When Ian Ozsvald interviewed him in 2021, the obvious story was that Vink had set out to build a better pandas. Ozsvald asked which frustrations had driven him. Vink corrected the premise: “Polars was not really designed because of Pandas pains.” His enthusiasm for Arrow mattered more to him than dissatisfaction with another library.

That distinction changes how his early decisions read. Vink was learning what his new tool could become, taking ideas from databases and from systems such as Dask and Spark. He described learning about CPU caches and multicore design while building Polars. Database query planners influenced its expression system: users could describe work in a form the engine could examine before carrying it out.

He was also willing to ask users to adapt. In the interview, Vink said Polars was becoming more stable but still had parts he wanted to improve; the project would not bend over backwards to avoid breaking changes. He had already replaced pandas in his employer’s production ingestion and joining code. This was a tool he used, while continuing to change the decisions inside it.

TECHNICAL NOTE

Planning the computation before running it

A lazy query plan records operations and their dependencies before executing them. It can show which columns a calculation needs, where rows are filtered and how the result will be grouped. Reading that representation gives a person a view of the computation without reconstructing it from a sequence of Python statements and intermediate objects. Vink explicitly named database planning as an influence, alongside Spark and Dask among the systems that informed his thinking.

The Polars guide gives a small example: read a CSV, group by an identifier and sum a value column. Because the lazy plan describes the whole request, the optimizer can identify that only those two columns are needed and limit the scan accordingly. The call to collect() triggers execution. In an eager sequence, each operation runs as it is called; avoiding unnecessary work depends more on what the programmer has arranged in advance.

The same representation could give a coding agent a more direct object to inspect when proposing an optimization. That is a possible use of the plan, not a measured result from Vink’s interview. The immediate benefit is already concrete: both the engine and the person examining the request can reason about the work before it happens.

Vink’s interest in changing the internals continued after Polars had become useful to others. In January 2024, he described rewriting its string representation as one of the largest refactors of his life. It was a change he had wanted for a long time.

Polars had depended on Arrow2, whose purpose included following the Arrow specification. At the end of 2023, the project brought parts of that implementation into its own polars-arrow fork. Vink could now tune it for Polars. Around the same time, Arrow was adding the string representation he wanted to its specification, preserving the prospect of interoperability.

His position was direct: Polars should work well with Arrow, but he was prepared to depart from particular types when they did not suit the application. Users would get the string change by upgrading Polars. They would not have to rewrite their queries to request it.

TECHNICAL NOTE

Moving references instead of text

In the earlier representation, selecting strings for a result meant copying their text into a new contiguous buffer. Long values made that expensive. The replacement uses fixed-size, 16-byte views: short strings fit inside the view, while longer ones are referenced in separate buffers. A join can therefore arrange views for its output while leaving the long text where it is. The cost moves toward copying small references rather than all the selected text. There is a tradeoff: a few surviving references can keep a much larger buffer alive, so reclaiming that memory may require copying again.

The refactor made a familiar operation cheaper by changing what happened underneath it. Vink’s account also records the condition that let him proceed: he had gained control of the relevant implementation. His freedom to improve the tool depended partly on how its code was organized between projects.

McKinney builds the archive

For msgvault, McKinney had a different way to reach an implementation. Coding agents helped him build a working program in Go, even though he had never written code in the language himself. His starting point remained specific: the missing attachment, the slow search, the wish to keep his correspondence privately.

He resented Google’s push to add AI features to Gmail while he still struggled to find old messages and attachments. He wanted the correspondence on his own computer, where he could search it quickly and choose how to use it, including with a local language model.

McKinney replaced the initial Python/Rust combination with Go. He found the single-language project faster to develop with coding agents and easier to distribute as one static binary.

TECHNICAL NOTE

The language affects the feedback loop

A coding agent can edit a program, compile it, run tests and use the failures to decide what to change next. Each repetition includes time spent waiting on the development tools. McKinney therefore gave more weight to fast release builds and tools that could be distributed and invoked easily. He preferred Go for that combination, while acknowledging Rust’s control over resources without a garbage collector. His comparison describes his work; it does not establish a general speed ranking for agent-built software.

McKinney had once spent years acquiring the skills to build a faster foundation for other people’s applications. With agents, he described a growing collection of tools he wanted for himself, some public and some intended to remain private. An accounting interface and a background code-review tool appeared alongside his other experiments. He was also working on projects during nights and weekends, as he had when pandas began.

“I’m working harder and having more fun building than I have in years,” he wrote. He was spending that time on software he wanted to use and keep under his own control. Owning the archive meant deciding how he would preserve it, as well as how quickly he could search it.

Hansson wants to change the computer he uses

David Heinemeier Hansson, the creator of Ruby on Rails and co-owner of 37signals, wanted the same control over the computer he used every day. He had long enjoyed programming and configuring it himself. Agents offered him a way to act on more of his preferences, including changes to software whose language or codebase would otherwise take time to learn.

His Omarchy project assembles Arch Linux, the Hyprland tiling window manager and a selection of configured applications into a Linux distribution. Hyprland manages the desktop’s windows; Omarchy supplies a chosen environment around it, with tools and visual defaults ready to use. Hansson was combining existing components into the working environment he wanted.

When he released Omarchy in June 2025, he offered other developers the setup he already ran himself. His preferences were the point. Someone could install it and use his choices unchanged, or take it as a starting point for their own configuration. He wanted to make that particular Linux experience easier to enjoy, without asking every newcomer to assemble it independently. The announcement described it as a sister project to his Ubuntu setup, Omakub; Arch was not his proposed starting point for everyone.

This was someone with decades of opinions about what made a computer pleasant to use. In his later writing, Hansson recalled more than forty years of affection for computers, including programming, games and configuration. Omarchy gave those preferences a concrete form that other people could run. Agents offered a way for users to take the next step: changing something he had chosen for them.

His April 2026 essay “The malleable computer” described Omarchy users with limited technical experience adapting the system with AI. Open source had long given them permission to do this. The work remained difficult, even for programmers who did not know an application’s language or could not spend the time learning its codebase. Hansson was interested in changes a person could keep using locally, whether or not anyone else wanted the same thing.

His own use of unfamiliar languages became explicit at Rails World in September. In a separate project, a new version of the HEY email service, he described early work on six native clients and a Rust backend. Agents had changed what he thought a small team could undertake. The clients were demonstrations of recently started work, not a completed rollout.

He disliked Rust’s appearance intensely and said he did not know the language. He would tell an agent what he wanted, let it write Rust and avoid reading the generated code. He described assessing the Rust component externally as a black box, comparing his role to an owner commissioning programmers. He tolerated verbosity in generated Rust that he would never accept in his own Ruby.

His experience also included a retreat. Earlier, designers had generated Basecamp features whose pull requests looked reasonable individually but damaged the architecture together. The team returned to manual review. By the keynote, he called that retreat mistaken, arguing that newer models changed what was possible.

He needed time to absorb the change. In August’s “Endless execution,” he wrote: “It’s taken months to internalize just what liberation this grants those with the ambition to imagine.” He had loved programming computers himself; he now described greater pleasure in being able to try the ideas that occurred to him. After years of programming, he knew what he liked and no longer wanted to write every change himself.

Omarchy gave him a working environment arranged to his taste, while the new HEY was an attempt to rebuild an email service with native clients and a Rust backend. A language he disliked could now be part of a product he wanted to build.

Learning the craft, choosing what to build

McKinney and Hansson came to agents with strong ideas about how software should work. Those ideas had developed through years of building and revising their own software. Mastery developed through practice, as it does in a craft: a problem gave them a reason to learn, and what they learned changed the solutions they could imagine.

Agents let them attempt more without first mastering another language. McKinney described a growing collection of projects; Hansson showed early work on six native HEY clients begun about a week earlier. Their accounts describe a faster route to trying an implementation and a wider range of projects within reach. Their experience also shapes how they use the agents. McKinney reconsidered the language for msgvault because repeated builds and tests, followed by distribution to users, mattered to the way he now worked. Hansson chose to accept unfamiliar Rust and judge the component by its behavior from the outside. He still specified what he wanted it to do.

An agent can produce bad code, misunderstand the problem or propose a solution that does not fit the application. Getting an implementation sooner gives no assurance that it is a good one. Hansson had already encountered this at Basecamp: generated features looked reasonable individually but damaged the architecture together. Judging a component from the outside also leaves the developer to work out which failures that assessment could miss.

The desire to own the result runs through these accounts. Ownership means taking responsibility for the software, including when an agent wrote its code. A team rebuilding an email service must decide whether the implementation meets its requirements and when it is ready for customers. The people making those decisions remain answerable for what they put into use.

Would a present-day AI have identified the need for something like Arrow on its own, or chosen to rethink an inefficient workflow? In these accounts, developers with long experience chose the problems and directed the agents. Their wishes and technical judgment shaped what they attempted. As more implementation is delegated, who will focus the AI’s work, give it tasks and decide how those tasks should be solved?


  • Mastery develops through practice, as it does in a craft. McKinney learned C while pursuing faster data processing; Vink improved an initially slow tool through repeated work. They learned from other developers, too.

  • Understanding the machine makes a problem easier to locate. CPU caches and memory layout helped Vink reason about performance; data representation mattered to McKinney’s application. Those concepts also give developers specific questions to investigate when an agent writes the implementation.

  • Curiosity can lead beyond the first complaint. A slow application led McKinney toward the cost of moving tables between systems. Vink’s enthusiasm for Arrow drew him into building a tool whose possibilities he learned as he worked.

  • Agents can extend the work an individual or small team attempts. McKinney built msgvault in Go; Hansson began a new HEY with native clients and a Rust backend. These are specific experiences, with HEY still at an early stage.

  • Hansson sets requirements and evaluates his Rust component without reading its code. His attention shifts toward what the software should do. Developers who work this way shape future applications through the needs they choose to address and the results they accept.

Sources

Previous Article

Scaling Context to 10M+ Tokens with Recursive Language Models

Next Article

The Post Hack Hangover - High Scores on Unfinished Tasks

Subscribe to our Newsletter

Subscribe to our email newsletter to get the latest posts delivered right to your email.
Pure inspiration, zero spam ✨