HaKatze: Arato.ai

Familiar Faces in a New World

The Zoom window popped open to a familiar face: my former big tech colleague, Tal Salmona. We used to chat about meeting fatigue and the constant struggle to find focus time. But catching up with Tal now, who currently leads engineering and cofounder at Arato.ai, revealed that our old problems are relics of a different era.

We, engineers, are no longer writing code; we’re supervising an army of autonomous agents. The friction and limitations do not derive from how fast someone can type, but from how many threads they can weave at the same time. 

Whereas people used to focus on DevOps … to improve organizational efficiency … today, we aren’t just trying to make humans more effective; we need to make the AI agents they operate more effective too. We are essentially rebuilding the software factory from scratch.

New Rules: When Traditions Morph

The original “Joel Test” had questions around daily builds, building in one step, and source control. These areas have blurred and morphed into the continuous integrating, building, and deploying pipeline juggernauts of today. 

Modern high-velocity assembly lines have transformed CI/CD from a passive deployment step into a floodgate that manages the massive volume of code generated by AI. In Joel’s era, Rule 2 asked whether you could make a build in one step, and Rule 3 asked if you made daily builds. Today, daily builds are a fundamental baseline. The new operational reality is managing blast radius and assembly line velocity when AI agents generate code at volumes human reviewers cannot maintain without help.

If the agent creates code at a much higher velocity, … we cannot review in the same way. … At a minimum, we need to filter what needs human eyes versus what can be reviewed solely by an agent … giving the human reviewer more information than they ever had before.

Because AI agents can generate pull requests, run them against temporary test environments, and validate fixes autonomously, the traditional barrier between engineering and product roles dissolves almost entirely. Product managers and non-engineers can now drive features end to end in sandboxed environments, leaving engineers to focus on architectural guardrails, complex new architectures, and sensitive areas.

Since we are adding way more code … faster, it is critical to have additional guardrails … in the CI/CD. … It acts as a critical dam for … the overflow of code that AI wants to push to production.

Interview Evolution: From Algos to Product Sense

Perhaps no classic principle has broken down as completely as Joel’s Rule 11: “Do new candidates write code during their interview?” When an LLM can write boilerplate syntax  and even more complex algorithms in seconds, watching a candidate write code on a whiteboard yields little signal about their ability to perform in a modern engineering team.

Interviews have changed drastically. Previously, we would look at: can they write code, system design, behavioral, etc. Now, writing code is no longer relevant … New [signal] items are product sense and problem solving with a coding agent. What choices do they make? What are the tradeoffs? How do they read and understand the spec?

Instead of testing syntax or asking candidates to write raw code by hand, the hiring process at Arato.ai evaluates four core vectors split across new AI-era priorities and evolved traditional standards:

• • New AI-Era Vectors
    • Product Sense: Evaluates whether an engineer understands customer needs and product trade-offs deeply enough to direct an AI agent without constant oversight.
    • Abstract Problem Solving: Gives a candidate a spec and assesses how they direct, plan, and iterate on a task using a coding agent in real time.
  • Evolved Traditional Vectors
    • Behavioral: Assesses communication, collaboration, and mindset with the exact same importance as before.
    • Architecture & System Design: Takes on expanded weight (absorbs part of the traditional coding interview) to evaluate how systems fit together, data flow, and where non-deterministic models might fail.

What This Means for Engineers: The Rise of the AI-Augmented Generalist

This shift redefines what it means to enter engineering, especially for new graduates. Memorizing textbook theory or grinding LeetCode won’t open doors at companies operating on the edge of innovation. They have moved past that.

With the power of AI agents, every engineer can and needs to become a DevOps specialist, graphic designer, product manager, project manager, team lead, and software architect. Because AI allows a single engineer to build a complete, deployed product over a single weekend, showing you can direct an agent (or mob of agents) to ship a project end-to-end is the new baseline, especially for new graduates or less experienced engineers.

Something has fallen out of sync from the old model… New skills are becoming more critical for engineers like communication and product understanding. Even skills like speaking with customer and understanding customer need is becoming more critical.

To land a role, candidates must demonstrate they can translate product needs into architectural guardrails without constant hand-holding. For more experienced engineers this expectation historically applied as they moved to senior levels like tech leads, architects, or staff engineers; now, self-direction and product sense are hard requirements across all engineering levels.

Archetypes are usually a senior IC aspect… This has become critical [for less senior levels] because product and architecture sense allows someone to become self driven and run faster with AI without guidance and stops and other pauses.

The New Bottleneck: Scaling Horizontally as a Solo Builder

The physical limit of software engineering used to be typing speed, deep-single-task focus, on-the-fly problem solving, and system design and planning. A developer spent days immersed in a single file or function. Today, the bottleneck has shifted entirely to horizontal orchestration: managing multiple parallel tasks without losing architectural coherence or context.

The person who can work with 5 agents [sessions] or more becomes an important skill. Previously, people would maybe work on one deep problem for days, but now that isn’t possible …, so you need to multi-task … Every engineer becomes a solo builder and takes missions from one end to the other end.

This shift creates a double-edged sword for engineering leaders. While a single engineer can now drive end-to-end projects independently, leading an organization becomes vastly more complex. When every developer manages a small army of coding agents, the effective number of “builders” scales drastically. To maintain control, leaders must leverage AI tools to synthesize real-time context and layer strategic direction across a massive, highly parallelized set of work.

The Verdict: Adaptability as the Core Metric

When evaluating whether a startup’s engineering culture will survive the AI transition, rigid adherence to 20-year-old checklists matters far less than organizational plasticity. The teams thriving right now are the ones willing to immediately discard stale practices the moment they become friction or antiquated.

In our conversation, the clearest signal of a high-performing AI-native team was how rapidly they abandoned old habits. They stopped running live-coding interviews, stripped out manual pull request write-ups, and restructured their CI/CD pipelines to treat AI agents as primary contributors rather than novel developer tools.

If you can fix the factory, the assembly line, you can increase velocity to almost no limits.

The ultimate metric for the AI age isn’t how fast your engineers can type or how many manual test cases you maintain. It is how quickly your team can adapt its internal factory floor as the capabilities of autonomous agents evolve.