Six months ago, Andrew Filev's engineering team had 36 people. Today, they're down to 30. Yet they're shipping 170% more code. That's not a typo, and it's not about working longer hours. It's what happens when an organization restructures itself around AI tooling—not as an experiment, but as the default way of building software.
Filev, founder and CEO of Zencoder, recently shared internal metrics from this transformation. Individual senior engineers who started 2025 working traditionally ended the year completing roughly twice as many pull requests. More striking: the business value increased even faster than raw output, driven by better test coverage and fewer production bugs. The company's quality assurance team, initially overwhelmed by the velocity spike, evolved into something closer to systems architects who build AI agents that generate and maintain acceptance tests.
These numbers matter because they represent something beyond productivity gains. They signal a fundamental restructuring of how software gets made—one that challenges assumptions about team composition, skill requirements, and where human judgment actually adds value.
The economics of trying things
Traditional software development operates under a specific constraint: change is expensive. You design carefully upfront because pivoting later costs weeks of engineering time. Agile methodologies helped, but even in two-week sprints, testing multiple product directions remained prohibitively costly. Teams picked one approach and committed.
AI-assisted development breaks this constraint by collapsing the cost of experimentation. Filev's team now moves from concept to working prototype in a single day—from initial idea through AI-generated product requirements and technical specifications to functional code. This isn't about moving faster through the same process; it's about making the process itself cheap enough to repeat.
The practical implications show up in unexpected places. Zencoder's website, critical for customer acquisition, evolved into a product-scale system with hundreds of custom components. The creative director now designs, develops, and maintains these directly in code. When the team decided to rewrite their CLI tool from Kotlin to TypeScript, they did it without disrupting release velocity. UX designers and project managers contribute production-ready code to fix UI details hours before launch.
This shift from "validate with mockups" to "validate with working software" changes what teams can learn and how quickly they learn it. Instead of debating whether a feature might work, they ship it, measure actual user behavior, and iterate. Major updates now ship every other month—a pace that would have required doubling headcount under the previous model.
Where the leverage moved
When AI generates implementation code, the bottleneck shifts from writing to validation. The critical skill becomes defining what "correct" looks like in machine-readable terms. For Zencoder, supporting 70+ programming languages and countless integrations means this isn't trivial.
Their QA engineers didn't become obsolete—they became more essential. But the work changed. Instead of manually testing features, they build AI agents that generate acceptance tests directly from requirements. These agents integrate into automated workflows that validate AI-generated code before it reaches production. If an agent can't validate its own work, it can't be trusted to generate production code.
This represents a genuine "shift left" in quality assurance. Validation isn't a separate phase that happens after development; it's embedded in the generation process itself. Product managers, tech leads, and data engineers now share responsibility for defining correctness criteria. The skill of making requirements explicit and testable has become cross-functional, not confined to a QA department.
For QA professionals, this moment resembles what happened to system administrators when cloud infrastructure emerged. The role didn't disappear—it elevated. Those who adapted became cloud architects and DevOps engineers with expanded influence. Similarly, QA engineers who learn to architect validation systems for AI workflows become critical enablers of the entire development process.
The geometry of software development is inverting
Software development traditionally followed a diamond shape: small product team defines requirements, large engineering team implements, small QA team validates. This geometry reflected where the work was. Implementation required the most people because writing code was the most time-intensive activity.
AI-first development inverts this structure into a double funnel. Humans engage deeply at the beginning—exploring options, defining intent, setting constraints—and again at the end, validating outcomes and making judgment calls about what ships. The middle, where AI executes, becomes faster and narrower. Fewer people are needed because the time-intensive work of translating requirements into code happens at machine speed.
This isn't just a workflow change; it's a structural transformation in how teams organize. The model resembles a control tower more than an assembly line. Humans set direction and boundaries, AI handles execution, and people step back in to validate before decisions reach production.
The implications for team composition are significant. Organizations may need fewer mid-level implementers and more people skilled at defining problems clearly and evaluating solutions critically. The career path for software engineers shifts from "write increasingly complex code" to "orchestrate increasingly sophisticated systems."
Engineering at the meta-layer
Every major abstraction in computing history—from assembly language to high-level languages, from on-premise servers to cloud infrastructure—raised the level at which humans operate. AI-assisted development continues this pattern. Engineers now work at a meta-layer: tuning agentic instructions, defining guardrails, orchestrating AI workflows, and making decisions about when AI output is safe to merge without human review.
These are genuinely new problems. How tightly should you bound agent autonomy in production systems? What signals actually indicate correctness at scale when you're shipping 170% more code? When is human review adding value versus creating bottlenecks? Teams are figuring this out in real-time, without established best practices to follow.
Filev describes this as "less like coding, more like thinking." That's both accurate and incomplete. It's thinking about systems, constraints, and risk in ways that require deep technical knowledge but manifest differently than traditional programming. The skills that matter most—clear problem definition, system design, critical evaluation—were always important. They're now the primary job.
For organizations considering this transition, the metrics matter less than the structural changes they represent. A 2x productivity increase is impressive, but the real story is how teams reorganize around AI tooling, what new skills become critical, and which roles evolve versus disappear. Companies that treat AI as a productivity booster for existing workflows will see incremental gains. Those that restructure around AI-first principles, as Zencoder did, are discovering what software development looks like when the fundamental constraint—the cost of change—approaches zero.
