Engineering: AI writes faster. Your compiler should review harder.
AI speeds up developers and attackers alike. Why we pair AI-assisted work with senior review, a strict compiler, and security as the first requirement.
· 4 min read
By Track49
AI has changed how fast code gets written. It has also changed who else can move fast.
Both of those facts matter to anyone who owns a system that handles money, claims or personal data. Here is how we think about them, and what we do differently because of them.
More code needs a stricter reviewer
We use AI every day. It handles repetitive work, drafts tests, sketches prototypes, and reads large legacy codebases quickly at the start of a modernization. That frees our engineers for the problems that need judgment.
But faster writing creates a review problem. If code arrives twice as fast, the people reviewing it don’t get twice as much time. Something has to scale with the volume.
Part of the answer is people. Senior engineers still review every change for intent and design, and they make the calls on architecture and trade-offs. AI makes suggestions and the team makes the decisions. Nothing ships until a person has checked it.
The other part of the answer is the language. Some mistakes are hard for a tired human to spot in a diff, and easy for a compiler to reject every time. So we choose stacks where the compiler does more of the reviewing.
What the Rust compiler refuses
Rust is our default for services and server-rendered web apps, mostly because of what it won’t let you do. In safe Rust, memory errors, data races and null are ruled out by the language. A missing case in a workflow is a build error, not a production incident, as long as nobody hides it behind a catch-all match arm. And with careful design, the rules of your business become types: states that shouldn’t exist can’t be written.
None of this replaces tests or review. It means people spend their attention on behavior and design, because the compiler has already rejected a long list of mechanical failures.
AI arms attackers too
The same tools that help us find bugs help attackers find them faster. Automated probing now reaches every public system, and the cost of trying an exploit against thousands of targets keeps falling.
That changes the order of priorities. Security can’t be a review at the end of a project. It has to be the first requirement, designed in from the start. In practice that means four things for us.
Memory safety by default. Memory bugs are behind a large share of serious vulnerabilities in systems software: about 70% of the vulnerabilities Microsoft assigns a CVE each year, and about 70% of serious security bugs in Chromium. Writing our own code in safe Rust takes that class off the table.
A strict Content Security Policy. The browser is told to run only scripts we serve, with no inline scripts or styles and no eval, on every page. If an attacker manages to inject markup, the browser refuses to run any script in it.
Smaller dependency trees. Every third-party package is code you didn’t write and probably haven’t read. Fewer of them means less to audit and fewer ways in through the supply chain. A compiled Rust service tends to need far fewer runtime pieces than a typical JavaScript stack.
Enforcement on the server. Validation, permissions and business rules live on the server. Pages work with JavaScript turned off. Anything that arrives from the browser is treated as untrusted.
Faster and leaner is a security feature too
AI features and automated traffic put more load on every system. A service that needs less memory and fewer machines costs less to run, and it also has fewer moving parts to patch.
A compiled Rust service usually runs in a fraction of the memory of the same service on a managed runtime, on smaller machines, with no separate language runtime to patch underneath it. Its dependencies still need patching, and a rebuild is how they get it. Render pages on the server and the browser receives little or no JavaScript. Less code shipped to the browser is less code for anyone to exploit there.
Keep people on the decisions
It would be easy to read all of this as “let the machines do it”. That’s the opposite of the point.
AI makes the routine parts of software faster. The compiler makes a set of mistakes impossible. That leaves the hard parts, the parts that decide whether a system is right: what it should do, who should be allowed to do it, what happens when it fails, and what you’ll need to change in three years. Those stay with experienced people, in writing, where your team can read the reasoning later.
After handoff, your AI tools inherit the guardrails
Your team will use AI coding tools on the system after we hand it over. The same setup protects them. Typed code, a real test suite and written project rules mean a wrong suggestion fails a build or a test before it reaches production, whoever or whatever wrote it.
Sources
- Microsoft Security Response Center, A proactive approach to more secure code, July 16, 2019.
- The Chromium Projects, Memory safety.
- ai
- rust
- security
- engineering