A team should be more ambitious with the software we build

Software engineer Michael Malis and systems researcher Dan Luu have argued that engineers should adopt significantly more ambitious goals for software development, pointing to substantial tooling projects like the pgrust database rewrite as concrete proof that complex systems work is now viable for small teams. As detailed in danluu.com's report, developers testing pgrust have already uncovered and submitted fixes for real upstream bugs in PostgreSQL, including a numerical bug that caused valid SP-GiST operations to fail, a format cache bug triggering incorrect JSONPath results, a pgcrypto bug that caused later operations to fail, a money overflow bug, and multiple memory safety bugs in the dictionary loader. The core focus of pgrust remains performance optimization, demonstrating that ambitious rewrites can yield durable upstream improvements and techniques that may eventually benefit databases such as Postgres and ClickHouse even if the full rewrite does not replace them.

This report examines how modern frontier reasoning models, fast hardware inference, and automated agentic testing are collapsing the time needed to build custom compilers, regex engines, and domain-specific software. It is written for software architects, systems engineers, and technical leads who are evaluating whether internal infrastructure rewrites and tooling prototypes are worth undertaking under contemporary development workflows. Rather than treating ambitious systems projects as speculative distractions that inevitably derail engineering roadmaps, modern results demonstrate that thorough benchmarking and comprehensive testing can turn previously intractable tasks into functioning utilities within single-digit developer hours.

A team should be more ambitious: what actually changed

The primary factor enabling greater ambition is that frontier model capabilities have advanced to the point where they eliminate the multi-year learning curve previously required to tackle complex infrastructure domains. When software engineers historically wanted to solve local developer friction by writing custom compilers, specialized interpreters, or domain-specific algorithms, doing so demanded deep specialization in fields like formal grammar parsing, string matching algorithms, or machine learning architectures. Today, developers without formal background in compilers or string matching can produce working custom tooling, including specialized regex libraries and ripgrep forks tailored for specific codex workloads, in a low single-digit number of engineering hours.

Furthermore, frontier models have moved past superficial code generation to genuine technical comprehension and implementation capability. Earlier models like GPT-5.1 and GPT-5.2 required intense manual steering because their technical suggestions were frequently incorrect, and attempts to have them implement techniques directly from research papers failed or resulted in code that merely mimicked the surface appearance of the algorithms. By contrast, newer models including Fable 5, Fable 5.1, Opus 5.5, GPT-5.6 Sol, and GPT-6 Astra can reliably read academic papers, extract the relevant technical methods, and implement functional systems such as superhuman board game engines and zstd compression implementations with minimal developer intervention.

A team should be more ambitious: how it works

Ambitious software development operates by pairing automated agentic generation with rigorous local benchmarking and exhaustive testing pipelines. Projects like pgrust succeed not by blindly trusting model code, but by subjecting the generated database engine to intensive test suites that expose edge cases in both the new codebase and the mature C implementation of PostgreSQL. The speed of iteration is further accelerated by high-throughput hardware platforms such as Cerebras, which OpenAI utilizes to serve state-of-the-art models at speeds ten to one hundred times faster than standard deployments, eliminating the latency bottlenecks that previously stalled agentic development loops.

When developers use high-speed frontier models to build custom infrastructure, local development bottlenecks shift toward operating system and machine overhead. Running rapid, automated agent loops makes ripgrep throughput, Rust compilation speed, and operating system syscalls and filesystem overhead the primary rate-limiting factors on developer machines. Developers address these bottlenecks directly by building customized native code compilers for regex matching, developing tailored Rust interpreters, and migrating development workflows from Mac to Linux to reduce the latency of small, repeated filesystem operations that standard operating system interfaces handle poorly under heavy agent activity.

A team should be more ambitious: why it matters now

The urgency behind adopting higher ambition stems from the fact that most engineering teams are operating under an obsolete, pre-agentic cost model. A decade ago, an engineer who paused work on an application to write a custom compiler or a new game engine was rightly seen as someone who would never ship a finished product, creating a strong cultural aversion among productive developers toward building custom foundational tooling. Maintaining that identical reluctance today causes teams to endure daily velocity bottlenecks, such as slow Rust compilation or suboptimal text searches, simply because they assume resolving those problems still requires months or years of dedicated systems programming.

Additionally, the capability trajectory of automated software generation continues to steepen over very short time horizons. In board game artificial intelligence development for Azul, achieving superhuman performance initially required five hours of developer time using GPT-5.1 and GPT-5.2, followed by twenty hours to surpass existing engines, including an engine used for cheating on Board Game Arena. Soon after, builder Gabriel Cangussu utilized Fable 5.1 and Opus 5.5 to construct an AI that decisively outperformed that earlier model while spending substantially less total developer time, proving that teams holding pre-agentic assumptions are continually outpaced by those leveraging updated reasoning tooling.

A team should be more ambitious: who is affected

This shift directly impacts systems programmers, database engineers, and open-source maintainers who evaluate modern infrastructure projects. While news aggregators frequently dismiss code rewrite initiatives as low-quality automated output lacking technical merit, rigorous projects are actively finding and patching critical flaws in established foundational software. Maintainers of critical systems like PostgreSQL benefit directly through external bug reports covering memory safety and numerical precision, while downstream database engines such as ClickHouse stand to gain from performance optimizations pioneered during ambitious rewrite attempts.

Application developers and infrastructure leads who spend considerable time wrestling with local tooling friction are equally affected. Developers who lack specialized theoretical training in string matching, interpreters, or computer science theory can now create functional, bespoke developer utilities tailored specifically to their proprietary workloads. However, realizing these gains requires individual engineers to move past the assumption that slow software and sluggish developer feedback loops are unchangeable constraints, recognizing that modern models allow individuals to quickly build custom solutions to longstanding pain points.

A team should be more ambitious: what to watch

The key factor to observe is the continued deployment of frontier reasoning architectures on high-speed specialized hardware, such as OpenAI models hosted on Cerebras infrastructure. As inference execution times drop by up to two orders of magnitude, software workflows will increasingly rely on automated agentic cycles to generate, verify, and benchmark code against comprehensive test suites. This shift will make automated verification frameworks, like those evaluated using GPT-5.6 Sol on medium and extra-high settings as well as GPT-6 Astra, essential for maintaining software quality across both custom and production codebases.

Industry observers should also track the rate at which experimental, high-ambition implementations translate their performance discoveries into mainstream open-source infrastructure. While low-quality, non-functional codebases remain common across the broader software ecosystem, projects that maintain strict benchmarking standards and aggressive bug-hunting regimens will continue to deliver measurable improvements. The long-term impact of these tools will be measured by whether engineering organizations overcome their historical aversion to infrastructure projects and begin building custom systems that solve their specific performance and compilation bottlenecks.