From the beginning, Square has always featured strong design sensibilities. Our first piece of hardware, the iconic credit card reader attached to smartphones, sought to replace ancient knucklebusters and clunky point-of-sale bricks. On the software side, our companion mobile apps were also the first of their kind.

When I joined the company in 2011, I became our second front-end engineer. We needed the help—on the web.

To be clear, we had an amazing mobile development team: many of Square's early engineers came from either Apple or Google or had already built prominent apps. The engineering team was only around 30 people, small enough that Square's CTO[1] insisted on meeting every engineering job candidate—as the final technical screen. I don't remember much about that interview, other than a sense of intimidation from his sharp thinking and obvious technical depth of knowledge.

The difficulty of the interview process was a double-edged sword: it kept the bar high, but made it difficult to meaningfully expand the web team. In contrast with mobile development, most front-end developers at the time came from a design background. Up to that point, web development was a mishmash of visual design and user interaction logic, implemented with three distinct technologies (HTML, CSS, and JavaScript). Backend engineers who aced algorithmic and architectural questions would receive tepid feedback from the product and design team; front-end engineers who built webpages to exact mockup specifications wouldn't be able to write running code to satisfy our engineers.

Meanwhile, the product kept expanding in conjunction with business success. We started figuring out what features made sense on mobile devices, which use cases merited a bigger iPad, and where a computer—with a bigger screen, mouse and keyboard, and robust file management—works better in the back office. We needed a dedicated web app, and took the opportunity to break away from the core system, built with Ruby on Rails. Our first task was thus picking which technology would serve as the project's foundation.

Now, front-end engineering in the 2010s saw a proliferation of sophisticated JavaScript web frameworks, sometimes referred to as Single-Page Applications (SPAs). Web browsers have gotten fast enough that much of the application and business logic that used to execute as server code could run directly within a browser tab, with the added benefit that user interfaces felt snappier. These frameworks augmented JavaScript—a rather spartan programming language—with design patterns, development best practices, and deliberate architectural choices. Paradoxically, having so many similarly positioned frameworks made it harder for us to make a confident technical decision.

The Decision(s) to Ember

It's already been 15 years, but I occasionally think back on that fateful selection: we chose to write Square's primary web app in a niche framework called SproutCore, which eventually became Ember.js. This call would set the course for front end development at Square for the ensuing decade.

Of course, technical decisions should be evaluated based on their operating environment. Of all the JS frameworks we tested, Ember.js was unique in how close it was, philosophically, to Ruby on Rails (RoR or just Rails). Specifically, both Rails and Ember:

  • Espoused strong opinions on file structures, classes and modules;
  • Leaned into conventions around naming and web-optimized design patterns;
  • Introduced procedures around data management, schema migrations, and breadth of testing that felt ahead of their time;
  • Normalized and promoted the practice of pair programming across the team.

We were carving away a part of the Rails codebase into its own app, but with Ember, we could keep a lot of what got us there.

This reasoning paid off when we built out the initial versions of what would be eventually deemed the Square Merchant Dashboard. Beyond making it much easier to iterate on the webapp, we spun out a dedicated team and put in effort for novel features centered around advanced filtering and data analysis. The Dashboard team started with three engineers, but we expanded to a dozen people before breaking out into separate teams to focus on upcoming products.

But I felt the framework's limitations only a few years into the app's development lifecycle. Its advanced abstractions around client-server interactions and data syncing never worked that well, and all its features weighed on both size and performance. Like Rails, Ember worked best as a single app, so as the number of contributors grew, engineers started to stomp on each other's toes in the shared codebase. In the front-end community, we noticed that the React framework, built and maintained by Facebook, was gaining prominence; it would eventually dominate the framework landscape and become the default technology for SPAs.

We did have opportunities to migrate away from Ember during my Square tenure, but decided against it every time[2]. We deemed it an expensive and risky project: the longer we built in Ember, the more our developers became attuned to its idiosyncrasies, which necessitated more onboarding efforts, resulting in more investment into the framework, etc. That initial choice evolved into a trap of self-reinforcement.

(The Lack of) Technical Difficulties

I'm reminded of this story from the olden days because the progress of AI coding agents is turning these considerations on their heads.

Let's start with the talent. It was hard to find good candidates in the early 2010s; few software engineers worked in the browser and most designers didn't wade deeply into JavaScript. A decade of intense web and SaaS development, though, produced enough engineers who wrote enough code that JS became the most common programming language[3].

The corpus of JavaScript—and its popular derivative language, TypeScript—is so large that it comprises a significant amount of model training data, to the point that AI agents code exceptionally well specifically in JavaScript and TypeScript. In turn, AI-driven web development is no longer bottlenecked on writing code or wrangling frameworks; both Claude and Codex do this faster, and more relentlessly, than human software engineers.

As is the case with native apps, then, what the software engineer provides is taste. AI can up-end 10,000 lines of code, scaffold a thousand tests, and even take screenshots to confirm components render as expected, but it cannot simulate how users experience the app without clear guidance. Those front-end engineers[4] with strong design backgrounds who couldn't pass the technical interviews in Square's formative years now embody the instincts and directions that complement a JS-heavy coding agent.

We also have to reconsider migration costs and benefits. With just software engineers, we have to account for the complexity and performance of each framework, the availability of engineering talent, and how the chosen architecture would enable or hinder future development. It's a canonical instance of Jeff Bezos's one-way door decision.

But given the advancement in AI coding capabilities, the cost to select—and to migrate off of—a framework drastically shrinks. Both OpenAI and Anthropic have successfully completed large rewrites of services at scale with groups of agents, and there's clear line of sight towards this style of reimplementation becoming broadly available in the next year or two. That is, we're still talking about concocting tens, hundreds of thousands of lines of working code from the æther, but in a matter of days instead of years.

This capability drastically changes the calculus of framework-level decisions. The embedded design patterns and best practices that frameworks espouse matter less when they're functionally interchangeable. In fact, there's the possibility of running implementations in parallel, just to test which one does a better job.

What Makes a Language

Since the advent of programming, there's been this tradeoff between raw performance and human-readability and understandability. Programmers started with assembly, manually pushing raw numbers into registers and performing I/O directly on memory. Other programmers then created higher-level programming languages to make it easier to understand the flow of 1s and 0s, and make core aspects of computation like memory easier to manage. Later languages further normalized design patterns, encouraged best practices, and even prioritized developer ergonomics.

AI may just obsolete all of these factors. If it can navigate assembler code—or in the modern web stack, WebAssembly—as easily as it can Ruby or Java, then the primary and perhaps only criterion is performance. Right now, Rust is a leading candidate for such an ur-language; both the aforementioned OpenAI and Anthropic projects rewrote into Rust, and it conveniently compiles down to WebAssembly as well.

Which makes this the likely path for Square's Ember apps… if it hasn't happened already.


  1. His name was Bob Lee; his accolades included inventing a framework at Google and building Cash App at Square. Unfortunately, he was in the news years later as a murder victim in San Francisco. ↩︎

  2. I kept checking with folks still at the company years later, and they confirmed the stubborn persistence of Ember on the team. I only noticed a shift when I found this job posting, from 2025, clearly stating the intention to finally move to React. ↩︎

  3. That said, being commonly used is very different from being enjoyed; when I wrote that I liked JS back in 2012, I got a ton of pushback in the Hacker News comments. ↩︎

  4. I'm also reminded of these specialists I worked with, so far only at Square, who spent their days honing-in on user interactions and animations in Quartz Composer and other such tools to refine prototypes before passing them off to software engineers to productionize. ↩︎