This pattern of radical productivity increases is now happening in software development. Today, with the right AI tools, developers can boost their productivity by a factor of three to four. In the near future, we can expect this to jump to 10x, and perhaps even 50x.

In previous posts, we’ve seen an AI Software Engineering Agent complete two hours of manual coding work in just two minutes. We’ve also explored how human + AI partnerships deliver superior results compared to humans working alone.

A Seismic Shift in Developer Work Patterns

A recent Gartner report anticipates a seismic shift:

“AI agents will transform developer work patterns by enabling developers to fully automate and offload more tasks. This will mark the beginning of AI-native software engineering, where most code is AI-generated rather than human-authored.”

Philip Walsh, Senior Principal Analyst at Gartner, added:

“In the AI-native era, software engineers will adopt an ‘AI-first’ mindset, focusing on steering AI agents toward the most relevant context and constraints for a given task. This makes natural-language prompt engineering and retrieval-augmented generation (RAG) essential skills for developers.”

We are entering this era now. These agents are available today and can deliver significant productivity gains immediately.

Estimating the Cost of Code

To put this into context, I asked Open AI’s new o1-preview model to estimate the cost of each line of code written by a senior engineer earning £80,000 per year. The estimate came out to roughly £2.40 per line of code, based on an average of 50 lines of code per hour and four hours of coding per day (* see Appendix below).

Over the past week, while figuring out how to market my new consultancy business, I’ve also used my dev kit to enhance itself. Here’s a screenshot of the new dashboard, showing this week’s work:

A total of 201 requests this week. The last one? I just made a small adjustment to improve the screenshot:

Add labels to the period drop down on the dashboard page so value all-time reads as “All Time” in the drop down and similarly for the other values.

This took 25 seconds, cost me 10 pence in Claude credits, and updated eight lines of code.

In total, I’ve spent roughly £50 on Claude this week and updated over 4,000 lines of code. If we use the £2.40 per line estimate, this equates to just under £10,000 in value generated. On average, each request took about one minute and updated 20 lines of code, costing 25p and delivering £50 in value.

Looking back, I’ve likely spent around half of each workday (Monday to Thursday) working on the Higher-Level Dev Kit. That’s approximately 16 hours in total—resulting in 250 lines of code per hour, a 5x increase over the industry average.

Every company with a software development team should be engaging with these AI tools today. Those that don’t will be at a severe disadvantage against those that do.

The Future of Software Engineering

I’ll leave you with some insightful words from Simon Willison, co-creator of Django:

“… when you combine expertise in using these tools with subject-matter expertise, you can operate at a level far above other people and the competitive advantage you get is enormous”

*Appendix: Calculating the Cost per Line of Code (LOC)

Obviously, this is a very rough estimate - and should be taken with a large pinch of salt.

For a UK-based Senior Back-End Engineer earning £80,000 annually, let’s recalculate the cost of producing each line of code, factoring in total costs to the employer.

Total Cost to Employer:

• Base Salary: £80,000
• Employer’s National Insurance Contributions (NICs): £9,784.20
• Employer’s Pension Contributions (5%): £4,000
• Overheads (20%): £16,000

Total Cost to Employer = £110,000

Estimating Productive Coding Hours:

• Working Days per Year: 227 (after accounting for leave and holidays)
• Total Working Hours per Year: 1,816
• Time Spent on Coding: 50% of total working hours = 908 hours

Lines of Code per Hour:

• Assumed Productivity: 50 LOC per hour

Total Lines of Code per Year:

• 908 hours × 50 LOC/hour = 45,400 LOC

Cost per Line of Code:

• Cost per LOC = £110,000 / 45,400 LOC = £2.42 per LOC

Summary: A senior engineer costs a company approximately £110,000 per year and produces roughly 45,400 lines of code annually, leading to an estimated cost of £2.42 per line of code.

Sources:

• UK Government Resources on Employer NICs
• Steve McConnell’s Software Estimation: Demystifying the Black Art (2006)
• Industry salary benchmarks via Glassdoor and Indeed

Capturing the Essence of Each Commit

I recently added a feature to my toolkit that captures the essence of each commit in a JSON file. This file is stored in the target repository under a .hldk/specs directory, effectively creating a history or story of the repository’s development. The idea was to have a structured way to document changes, making it easier to track progress and understand the evolution of the codebase.

Tracking Test Lines Changed

Building on that, I wanted to differentiate between changes made to production code and test code. Specifically, I aimed to track testLinesChanged — the number of lines changed in test files as opposed to production files. Adding this metric will allow us to track the relative cost of changes to test code as opposed to production code

The Git Update That Surprised Me

I instructed Claude to implement this feature with the following mini-spec:

update mutation entity to add testLinesChanged similar to linesChanged but 
is only populated if the filePath contains the string "test" (any case) 
otherwise it's set to 0. Update the service and repo as necessary to set 
testLinesChanged and also add methods for getTestLinesChangedForSession|Request. 
Also add the flyway migration.

And here’s the result—the contents of the generated JSON file that was included in the commit:

{
  "spec": "update mutation entity to add testLinesChanged similar to linesChanged but is only populated if the filePath contains the string \"test\" (any case) otherwise it's set to 0. Update the service and repo as necessary to set testLinesChanged and also add methods for getTestLinesChangedForSession|Request. Also add the flyway migration.",
  "commitMessage": "Add testLinesChanged feature to mutations",
  "stats": {
    "processingMillis": 65294,
    "inputTokens": 100931,
    "outputTokens": 4587,
    "totalTokens": 105518,
    "cost": 0.2786985,
    "linesChanged": 71,
    "currency": "gbp"
  }
}

Beyond Expectations

What surprised me was that Claude not only implemented the feature flawlessly, adding 71 lines of code in just over 1 minute at a cost of 28p, but also added an update line to the Flyway migration script to backfill the testLinesChanged data in the existing database—a step I hadn’t even considered.

Here’s the Flyway migration that it generated:

ALTER TABLE mutations ADD COLUMN testLinesChanged INTEGER DEFAULT 0;

UPDATE mutations SET testLinesChanged = linesChanged WHERE LOWER(filePath) LIKE '%test%';

CREATE INDEX idx_mutations_test_lines_changed ON mutations (testLinesChanged);

By adding this extra line, Claude ensured that all historical data was consistent with the new feature, allowing for accurate analytics from the moment of implementation.

The Power of AI-Augmented Development

This experience reinforces the incredible potential of AI-augmented development:

• Speed: Tasks that would typically take hours are completed in minutes.
• Insight: The AI doesn’t just follow instructions—it understands the context and identifies improvements.
• Efficiency: With AI handling the heavy lifting, developers can focus on higher-level problem-solving.

Embracing the New Paradigm

This is not just a one-off occurrence. I’ve been consistently experiencing similar enhancements while using the Higher Level Dev Kit with Claude Sonnet 3.5. The AI agent:

• Understands the codebase layout and adapts accordingly.
• Replicates coding styles and best practices, ensuring consistency.
• Identifies potential improvements that may not be immediately obvious.

By embracing AI-augmented development, we unlock unprecedented productivity and insight, allowing us to focus on more innovative and creative tasks.

Just a few days later, on Monday the 24th, I was made redundant from the fintech payments company where I had been working for over six years, as it prepared to shut down. In hindsight, I believe this turn of events was quite serendipitous.

I had already been experimenting with ChatGPT and other large language models (LLMs), trying to leverage them to become more productive in my role as a backend engineer. But with Claude Sonnet 3.5, we finally had an LLM capable of writing decent, reliable code that was mostly bug-free.

This changed everything.

Given six weeks of gardening leave, I decided to immerse myself in this new world instead of searching for another job. I started by dabbling in Python and learning about frameworks like LangChain and LangGraph.

By pasting existing code into Claude and asking it to build the next part, then incorporating that back into my IDE, I managed to build a Python-based server running some agents and a rudimentary web app to interact with them.

One of the agents I developed was called the System Improver Bot. It functioned by providing it with the root folder of a code repository (I simply pointed it to itself) and sending the tree of source file names to Claude along with instructions on what to do next.

By equipping Claude with a read_file tool, it could decide which files it needed to read to understand the codebase before generating new code. By parsing the responses, I could automatically save the generated code back to the file system.

I no longer needed the Claude UI at all, and my productivity skyrocketed. It didn’t matter that I didn’t really know Python or that I was a complete novice at web development.

I’m now developing in the English language - this is Higher Level Development.

After 25 years of building backend systems in the Java ecosystem, I’ve finally become a 10x Engineer. And it’s a lot of fun. And any other developer can do the same with access to the right tools and a few days to get up to speed on how to direct the agent.

It’s a new paradigm: you develop one small specification at a time. For example:

Add a new person module to the system. 
The Person entity needs properties:id (UUID), title, firstName, 
lastName, dob (string), createdAt (timestamp). 
Add the appropriate repository with the usual methods, 
the service and controller, and all the necessary DTOs and unit tests. 
Also, add a Flyway migration for the new person table.

This task usually involves a lot of boilerplate code and might have taken at least an hour or two in the past. But a Claude-powered coding agent can do an excellent job of this in about two minutes.

Claude can see the codebase layout and examine other modules in the system. It learns how entities are structured and replicates the same style and tooling.

I’ve been using this methodology over the past (checks notes…) 2 weeks (!?!) to build a new production-ready version of my toolkit.. this time the tech stack is a NestJS/Node server and a Vue3 web UI.

Here’s a video of the new tool implementing the above mini-spec in a Java Spring Boot git repo:

At the end, it also runs the tests—including the newly created unit tests—and verifies that everything is working. If it wasn’t working then it would iterate fix -> test -> fix –> test until everything was working correctly.

Generating new code like this is fairly straightforward, but Claude Sonnet 3.5 also excels at making edits to existing code and even performing refactorings of limited size. As a general rule, if I anticipate changes to more than ten files at once, I tend to break the work down into smaller specs and iterate through them one at a time.

The toolkit I’ve developed will automatically commit each set of changes to Git with a suitable commit message. If you’re not satisfied with the changes, a simple “undo” is enough to revert them.

Though the example uses a Java Spring Boot application, the Higher Level Dev Kit is designed for versatility across any codebase. Whether you’re working in Node.js, .NET, Python, Go, building Android or iOS apps, or using React, Angular, or Next.js, the toolkit seamlessly adapts to your stack. By allowing developers to hand off coding tasks to an LLM agent through concise specs written in English (or other native languages), it transforms how you approach development, letting you focus on higher-level problem-solving while the agent handles the details.

This is how I do all my development now. There’s no going back or putting the genie back in the bottle.

This is the way.

Based on what I’ve learned and the excellent results I’ve been seeing so far using this approach, I’m starting my own boutique consultancy, offering to help companies radically improve their developer productivity by adopting this same toolkit and workflow.

My goal is to build a sustainable business, fostering long-term relationships with a small set of software teams, so they can leverage the Higher Level Dev Kit to supercharge their development in a totally affordable way.

Together, we can improve the toolkit, incorporate the latest and greatest LLM models (o1 anyone?), and be at the forefront of AI-augmented development.

Early Bird Offer till end of October: Book your free consultation now!