When code gets cheap, judgement is the work

AI writes a lot of our code now, and it still gets things wrong. Why deciding what to build, and checking it, matters more than it did before.

Ausaff Shakeel26 October 20265 min read
Building NearSync
When code gets cheap, judgement is the work
26 October 2026

There is a popular argument that AI has become a flawless senior engineer: the machines no longer make mistakes, and the only thing left for people to do is design. Half of that is right.

Here is what we believe, from building NearSync every day with AI in the loop. AI writes a large share of our code. It is fast, it is often good, and it is regularly wrong in ways that look right. That makes two things more important than they used to be: deciding what to build and how it should feel, and checking that what got built is true. Neither of those is going away. Both are now most of the job.

What changes when code is cheap

For most of the history of software, writing the code was the slow part. A feature took weeks because someone had to type it, test it and fix it. That cost forced a kind of discipline. You thought hard before you started, because starting was expensive.

That cost has dropped a long way. A screen that took a week can take an afternoon. A migration script, a report, an importer for a new file format: the first draft now arrives in minutes.

The obvious result is that you can build more. The less obvious result is that you can build the wrong thing faster than ever, and fill a product with features nobody asked for. When typing stops being the bottleneck, the bottleneck moves to the decisions around it. What should this do? Who is it for? What should it refuse to do? How should it feel on a long Tuesday afternoon?

Those questions do not get easier because the code got cheaper. They get more frequent.

AI writes plausible code, and plausible is not correct

AI does make mistakes, and it is worth being specific about which ones.

AI rarely makes the mistakes people expect, like a missing bracket. It makes the mistakes a confident new hire makes. It calls a function that sounds right but does not exist in this part of the code. It copies a list of values that already lives somewhere else, and the copy quietly drifts. It writes a check that passes in the build and fails the first time a real customer clicks the button.

None of that is a reason to stop using it. It is a reason to treat its output the way you would treat any colleague's: read it, test it, and never assume a green tick means it works.

Checking is a system, not a step

The more code gets written, the more there is to check, and the checks themselves are code that can break. A test run can stop running and still look like a test run. A build can skip a check without anyone deciding it should. So the checking has to be watched as carefully as the product: it needs its own tests, its own alarms, and someone who notices when it goes quiet.

How we check the work now

Here is what stands between a change and our customers today.

  • More than 850 files of automated tests. Over 400 cover the web app, around 100 cover the mobile app, and just over 300 cover the back-end services that generate documents, handle messages and run the AI. The web app and back-end tests run on every proposed change and every night.
  • Tests that try to break the tests. The code that handles money, permissions and keeping each company's data separate gets mutation testing every night. A tool deliberately introduces small bugs into that code and checks that our tests notice. The score has a floor, and lowering it needs a reviewed reason.
  • Proving things by doing them. Every change builds a fresh copy of the whole system from scratch and then actually performs the paths everything else depends on, rather than only checking that the right pieces exist. A check that only counts things can stay green while the thing it counts no longer works.
  • One way into production. Production only accepts changes that have already been through our staging environment. A check enforces that, so it does not depend on anyone remembering.
  • A person reads it. AI drafts, and an engineer reviews, runs it, and owns what ships.

None of this is unusual on its own. What has changed is how much of it we lean on. When one engineer with AI can produce in a day what a team used to produce in a week, the checks have to scale with the output, or the mistakes do.

The other half of the work is taste

Checking tells you whether the code does what you said. It cannot tell you whether what you said was right. That part is design, in the widest sense: what the product does, what it leaves out, and how it treats the person using it.

Some of our clearest decisions have nothing to do with code at all:

  • No amber, anywhere. We do not use amber to signal stress or push a decision. People spend their working day on this screen, and it should not feel like a production line.
  • Leave actually means leave. On approved leave, calls do not ring and notifications arrive silently. The system knows you are off.
  • Breaks are part of the work. Vitality is one of the rings on the home screen, next to the rings for the work itself.

An AI can implement any of those in an afternoon. It would not have suggested any of them. Each one came from someone deciding what kind of product this should be, and then holding to it when a shortcut was available.

The same goes for the harder product calls. NearSync puts sales, finance, people and payroll, projects, support and chat in one system for UAE businesses, with AI working in every team. Deciding how a deal, an invoice and a payslip should relate, and what a manager should see first in the morning, is not a coding problem. It is a judgement about how a business actually runs.

Where that leaves us

People often say product design is the final moat. We would put it more plainly. When code gets cheap, the scarce things are knowing what to build, knowing how it should feel, and knowing that it works. AI helps with all three. It replaces none of them.

So we use it heavily, and we check it heavily. We write down what a feature must do before anyone writes it. We review every change. We keep a test suite large enough that a quiet mistake has somewhere to get caught, and we watch the suite itself.

If you want to see what that approach produces, the values behind it are on our about page, and the way we hire for judgement is on careers. Or see what NearSync AI includes and try it with your own team.

See the product

Every module in one workspace. What shipped recently is in the changelog.

See the productRead the changelog

What changed for UAE businesses this month. We email once a month.