First-party software

Software development is currently undergoing a large shift, with the economics of developing and maintaining software changing fast. Like all rapid technological change, it’s very unevenly distributed. Most people I talk to outside of San Francisco don’t see it at all, even the developers. So I want to share my personal experience and a few thoughts on where this is headed.

To summarize: we're approaching a point where building custom software—something historically practical only for large companies—is becoming affordable for many more businesses. Most people don't see it yet, but it’s significant, and it will change the way people buy software. I want to share some practical examples and thoughts.

First, my background. I’m not a developer. I’ve written some code for about six or seven years, on and off, sometimes not at all for 6 months and sometimes every day for a couple of months. Mostly to build little scripts here and there to make me more productive, and partly because I enjoyed the problem solving aspect of it. The most advanced ‘product’ I ever built was probably a collection of scripts running in replit that did a bunch of data transformations and analysis. Definitely helpful, but I could have achieved the same through a complicated excel file.

Because I understand software conceptually (I’ve worked closely with technical / quantitative teams for a lot of my career), but am not particularly good at writing software, I was in the perfect position to benefit from LLMs. Given my position and my interests, I’ve spent a huge portion of the last 3 years writing code with these models. I’ve seen firsthand how quickly they’ve improved, because my own productivity is so closely tied to their capabilities. In the last 9 months, my ability to write and manage software has inflected upward. This inflection began on June 20th last year, the day claude-3-5-sonnet-20240620 was released.

To make this more concrete, in the last two months, I’ve built two apps, both for my family’s ecommerce business:

1. A Gmail add-on that integrates with shopify and openrouter to automate customer email management

2. A fullstack web app that integrates with shopify, fb, google ads, and openrouter to manage a huge portion of our business – everything from sales reporting, inventory management and reconciling shipments and payments from our supplier

Below, I’ll describe each app in more detail and then cover why I think this matters.

Gmail Add-on

When I went home for the holidays I watched my mum respond to some emails from her customers and noticed two things:

1. Most of the time, she was just copying and pasting a template and making some changes. When I asked why, it was because so many emails take the form ‘has my order shipped yet’ or ‘what is the returns policy, the dress I bought it too big’

2. For every single email, she was pasting it into ChatGPT and then copying the output back into Gmail before sending. When I asked why, she said that it ‘made all of her emails better’

I realized after watching and asking some more that she spent about 2 hours per day (!) doing this work. Certain this was unnecessary and armed with Claude (Sonnet-3.7 by this point) I spent two days and built a working Gmail Add-on which does the following:

1. When you open an email, you can send its contents to an LLM (we use Gemini-Flash for cost reasons) to classify the email (e.g., ‘Shipping and Tracking’), run sentiment analysis (e.g., ‘Neutral’), and identify any products or order IDs they mentioned (the former is achieved by loading in a list of our SKUs and the latter is just extracting alphanumeric codes with a few examples given to Gemini)

2. Using the sender address, fetch the order history and customer profile from Shopify, along with the inventory and price data for any products they mentioned. This is all loaded into the sidebar in Gmail and hyperlinked, giving the user an easy way to quickly view any of the customer orders, see the fulfillment status, etc

3. Allow the user to – in one click – send all of this to GPT-4o (it seems to write the most natural sounding emails) along with the thread and have it write a draft email

The net result of the above is that 80%+ of all emails are now written by GPT-4o. Everything is handled in a single window, and the user has full control to review or fall back on manual responses. There is also the ability to use GPT-4o to rewrite the email based on a simple text prompt (e.g., make it more casual).

In two days, this went from idea to production and has reduced time spent on this by at least half.

Reporting App

The second example is a different story. Frustrated by how difficult it was to answer the types of questions I had about the business e.g., ‘sales are up 35% year-on-year, is this being driven by price, volume or mix-shift’, or even better ‘volumes are up but is that because you have more customers or customers are buying more’, I decided to build a ‘simple’ reporting app. Initially this was just syncing data from shopify – sales, refunds, products, etc – into a simple replit app with a postgres db and then spinning up a few pages showing the type of info I wanted to see.

Over the last two months this has expanded. It now does:

• Sales reporting like I mentioned above with sales and product data updated at least hourly through either regular polling or webhooks Tracking ad spend by fetching from fb and google APIs and showing historical trends

• Allowing us to create orders in a custom UI that is designed to put all the information we need in one place based on the way we order, and exporting a csv in exactly the format our supplier requires

• Allowing us to track incoming shipment from our supplier, and matching them to orders Allowing us to log invoices from our supplier, and matching them to both the orders and the shipments

The functionality discussed above can be broken into two categories:

1. Things we wanted to do but couldn’t with our existing set of products (e.g., sales reporting)

2. Things we had to do but were incredibly time consuming (tracking shipments and payments against orders). This sounds simple, but when your overseas supplier sends you an order in five pieces, each without any documentation, and then invoices you two months later for all of two orders and three quarters of a third, it gets hard to manage)

This app has grown to about 15k lines of code. Although I closely managed its build, and made most of the design choices in the architecture and implementation, I wrote ~0% of these.

Why does this matter?

Historically, software has been expensive to build and perhaps just as expensive to maintain. Small businesses could not realistically build these types of tools. They could either find an off-the-shelf solution or they could live without it. Even with the proliferation of SaaS products, I suspect most instances of ‘software could improve this’ are stuck in the second bucket – being managed manually in a spreadsheet, or on a piece of paper. However, this shift in software economics significantly impacts competitiveness. Businesses that adopt first-party software gain a substantial advantage by precisely tailoring tools to their unique needs, achieving efficiencies that generic products can't match. I’m not saying that buying software is done and everyone will build their own products. I suspect many people will continue to want a provider to manage things for them, adding features as needed and proving some SLAs. But on the margin, building software has gotten an order of magnitude cheaper, and appears set to continue on this trend for the foreseeable future.

I expect that this category of first-party software – custom apps that are built for a precise purpose, and are cheap enough to produce and maintain that it makes no sense to compromise – will be huge. Today, with a combination of Cursor/Claude Code/Cline/etc for development, and Replit for one-click deployment, the frontier is well beyond what most people realize.

One more thing I want to note here is that even over the two months that I’ve worked on this intermittently, adding functionality and debugging has gotten significantly easier. Two months ago I’d go back and forward with Claude/ChatGPT in a chat UI, planning and writing code and copying and pasting back and forward to build and debug. Compare that to the most recent feature I added and bug I found. I spent about 5 minutes writing both into a markdown file in my project. I opened Claude Code and asked it to read the file and create a plan. It did, and then it implement both for <$2 in about three minutes (including time to test it’s work and make some corrections). I opened Replit and clicked deploy. Five minutes later, my mum had access.

What’s next

It’s well beyond time to start planning. We already know for sure that:

• These models will keep improving (OpenAI have already said that their internal o4 benchmark is a meaningful jump in competitive programming over o3, which itself it still unreleased! I’m sure Claude 4 Sonnet/Opus are also on their way)

• For a given level of capability, costs will continue to fall quickly

• Many more unhobblings will be handled – Claude code is already starting to be given browser access via MCP to test it’s work, context lengths will grow, clever tools will be added

• The app layer will continue to wire these things together. A year ago many people could produce code in ChatGPT but had no idea how to run it. Today, it will execute it for you in many cases, and make it shareable. The barriers for the ‘schlep’ around running and deploying code are falling

I suspect agencies that build and maintain these solutions at huge scale will do very well. As will whoever makes it easy to do this end-to-end, from idea to deployment (Replit is the closest here in my experience). I’m not sure what will happen to developers. It seems hard for me to imagine that anyone non-specialized will not have their power reduced in the labor market. I don’t think I’d bet on mass layoffs, but I probably wouldn’t bet on the next 10 years looking like the last 10 in terms of labor market power for a software developer. That said, the uncertainty level is high, and the best thing you can do is get as familiar as possible with these models. Learn where their edges are. Learn how to best utilize them. The more time you spend with them, the better your chance at working out where to position yourself in the coming years.