Seeing AGI (8): The Rebirth of the Human Role
I recently attended Delight Spark in San Francisco, and one conversation stayed with me long after the event ended. It was about AI organizations.
Across my past seven Seeing AGI articles, I have written about AGI's arrival, vibe working, and multi-agent systems. But the question I keep coming back to is simpler: what happens to the human role inside the company? Before AI rewrites the org chart, it rewrites the person.
Too many companies still treat AI as a software upgrade for the same people in the same jobs. That is the wrong frame. AI is not just speeding up work. It is changing who does what, who owns context, and how judgment moves.
Every Technology Wave Changes the Human Role
When people encounter a breakthrough technology, they usually assume their job will stay exactly the same, just faster. History shows us this is an illusion.
The first thing that changes is rarely the org chart on paper. The first thing that changes is what human beings do all day, who they depend on, who they report to, and what kind of judgment the system actually rewards.
So if we want to understand AI clearly, we should not only ask what the models can do. We should ask what earlier technology waves did to work itself.
Electricity did not just modernize the factory. It changed the people inside it.
The famous lesson from electrification is not just that electricity was powerful. It is that the first wave of adoption underdelivered because factories kept the old layout. Owners replaced steam engines with dynamos, but kept the same centralized power logic, the same line shafts, the same belts, and the same production geometry.
The real leap came later, when factories adopted unit drive — individual electric motors at the machine level. At that point, the building itself could change. Single-story layouts became easier. Machines no longer had to be organized around one mechanical spine. Workflow could be redesigned around speed, safety, and specialization.
And once the factory changed, the human roles changed with it. The old logic of central engine rooms, shaft-driven layouts, and maintenance built around one power source started to fade. In its place came a new need for electricians, electrical engineers, factory planners, and a new kind of operations management. Paul David wrote that large-scale electrification required building up "a cadre of experienced factory architects and electrical engineers." That is exactly the point. A new power source did not simply make old workers faster. It created new specialists, new reporting relationships, and new operating logic.
Computers did not just automate offices. They created entirely new information roles.
The computer era did something similar. Before computerization, large organizations relied on layers of clerks, typists, filing staff, bookkeepers, and machine operators to move information by hand. Then came data-processing departments, keypunch operators, programmers, systems analysts, and later database administrators and IT managers.
Some roles shrank. Others appeared from nowhere. Keypunch operators became a recognizable occupation in the punch card era and then gradually disappeared as direct computing spread. At the same time, the systems analyst emerged as a new bridge role — someone who could understand the business, design the system, prepare diagrams for programmers, and translate management needs into technical structure. That role only makes sense in a world where software becomes part of how the company thinks.
This also changed reporting lines. Once information systems became central to operations, companies built MIS and IT organizations, project management layers, systems teams, and later enterprise software functions. Authority increasingly flowed through information architecture, not just physical operations.
Software created the modern product organization.
Then the software era added another layer. As software complexity exploded, the organization split again. Product management rose to fill a gap between business, users, and engineering. In software, it was not enough to market a product. Someone had to decide what to build, translate user scenarios, and stay close to engineering throughout the cycle.
UX and interaction design matured as personal computing and then the web made usability economically unavoidable. Quality assurance became a distinct function because testing could no longer stay inside the head of the programmer. Later, Agile and DevOps started blurring those lines again, pulling testers earlier into the cycle and making quality a shared responsibility.
So the PM, Designer, Developer, and Tester structure was not handed down by nature. It belonged to the previous era of software engineering. It was a rational response to the limits of human communication, fragmented knowledge, manual coding, and slower feedback loops.
The Old Assembly Line Was Built for a Different World
Once you see that history clearly, the current software org chart looks much less permanent than most people think. It is simply the latest layer in a long sequence of technological reorganizations.
In the old software world, a project needed a deep stack of specialized functions before it could move an inch. The reporting logic usually reflected the workflow itself: product produced requirements, design translated them, engineering implemented them, QA validated them, and management coordinated the handoffs between those silos.
Think about what a PM used to do: they spent weeks writing massive, 20-page specification documents to throw over a wall. The Designer then spent weeks manually pushing pixels to translate that spec into mockups. The Developer took those mockups and spent months typing boilerplate code. Finally, the Tester spent weeks hunting down misalignments and bugs.
That structure made sense when each step had to be performed by a different specialist using different tools, with expensive transitions between them. Handoffs were not just bureaucracy. They were how the system protected itself from complexity.
But when an AI agent can help generate the code, draft the UI, create test cases, and compress iteration into minutes, the same structure starts working against itself. The handoff goes from being a safety mechanism to being pure drag.
Most "AI transformation" today is still trapped here. Companies give an AI writing tool to the PM, an AI design tool to the Designer, and an AI coding tool to the Developer, but keep the same reporting lines and the same division of labor. It is connecting a new power source to an old machine.
That is why I believe the front part of this story matters so much. AI is not the first technology to reorder work. But it may be the first one that does it at this speed while also collapsing so many knowledge roles into the same moment of execution.
What I Am Seeing Inside Genspark
Inside Genspark, I can already see the next layer of that history being written in real time. We are now an organization of around 70 people. Our structure is ruthlessly flat.
We do not staff projects with massive, multi-disciplinary departments. The vast majority of our projects are executed by agile pods of just 1 to 3 people. Because the workflow is compressed, people operate intimately close to the full chain of value creation.
This begins on day one. New employees are not hidden away in narrow roles or forced to read documentation for a month. They are pushed to the front lines immediately. We routinely see people shipping real, complex functionality in their very first week. Even team members who had never written a single line of code in their lives before joining us are launching features.
In the last era, that would have sounded reckless or impossible. In this era, it is the baseline. Ambitious people thrive here because they are no longer trapped in a single box.
How the Roles Are Actually Changing
When the workflow compresses this aggressively, professional roles do not disappear. They mutate. They elevate.
The PM: From Spec Writer to System Director
The PM no longer spends weeks writing static documents for someone else to interpret. They use AI to generate live prototypes immediately. They are steering the system, testing logic in real-time, and owning the final outcome rather than just owning the requirements.
The Designer: From Front-End Translator to Final Judge
Our recent release of Genspark Design is the perfect example. In the old process, the Designer was a front-loaded translator. They had to manually draw the screens before anyone else could build. Today, the path from an abstract idea to a complete design to a launched product is continuous.
Because AI can generate dozens of high-fidelity functional prototypes in seconds, the Designer's role moves to the back of the pipeline. They become the judge. They set the quality bar. They protect the taste level. They sign off on the experience. They decide which of the AI's iterations possesses the right soul for the brand.
The Developer: From Code Typist to System Architect
A developer's first week is no longer about setting up local environments and reading old codebases. It is about shipping. They spend less time typing boilerplate and more time architecting logic, guiding agents, and solving the deep, structural problems that AI cannot yet see.
The Tester: From Manual Gatekeeper to Agent Infrastructure Engineer
In the AI-native workflow, everyone becomes the tester of their own feature. The person building the feature is also generating cases, checking edge conditions, validating the experience, and deciding whether it is ready to ship. Testing no longer sits at the end of the chain as a separate gate. It becomes part of authorship itself.
That does not mean the traditional tester disappears. The role moves up a level. It becomes an infrastructure role. Instead of manually checking every screen after the fact, this person helps make sure that once features are shipped across the team, the system remains stable, observable, and trustworthy in production.
In that sense, the new tester looks more like an infrastructure engineer for quality. They build the frameworks, guardrails, monitoring, evaluation loops, and release logic that make the whole organization more reliable. They also help create infrastructure that is more agent-friendly, so AI can participate in testing, debugging, and continuous improvement more effectively.
Across every discipline, the trend is exactly the same: judgment is becoming far more important than handoff. Context ownership is becoming more valuable than narrow specialization.
The CEO: From Chief Executive Officer to Chief Context Officer
Once you see how deeply AI is recombining roles, you cannot stop at PMs, Designers, Developers, and Testers. The CEO is being rewritten too.
In the old company model, scale pushed the CEO away from the work. The organization became too specialized, too layered, and too slow. The CEO's job became managing complexity through other people.
That distance was not a personality trait. It was structural. In many companies, the CEO could no longer touch the product directly because the work had been fragmented across too many functions, meetings, and handoffs.
AI breaks that model. A CEO who is willing to learn can step back into the work. They can explore product ideas, review prototypes, test flows, challenge assumptions, and even help drive execution with AI. Not because the CEO should become a micromanager again, but because the wall between leadership and creation is getting thinner.
So the job changes. The AI-era CEO starts to look less like a Chief Executive Officer and more like a Chief Context Officer. The role is to set direction, clarify judgment, move decision rights closer to the edge, and design the interfaces that let small pods move with real ownership.
In the old model, power came from distance and control. In the new model, power comes from context, taste, clarity, and the ability to help the organization think and move as one system. And once the CEO changes, the organization cannot stay the same. Role rewrite naturally becomes org rewrite.
The new organization is not just flatter. It is structurally different.
I do not think the right description for this new company is simply "flat." Flat only means fewer layers. What we are seeing is a deeper change than that. The basic unit of the organization is no longer the function. It is the pod.
In the old structure, the company was built around departments. Product sat in one place. Design sat in another. Engineering sat somewhere else. QA sat at the end. The org chart mirrored the handoff chain.
In the new structure, the company starts to look more like a network of small, high-context pods. A pod of 1 to 3 people works close to the problem, close to the user, and close to the AI. It owns more of the chain from idea to release. It carries more context. It makes more decisions. It waits less.
In a company of thousands, this cannot mean one CEO directly touching hundreds of pods. That does not scale. The scalable version is a network of networks: pods grouped into mission clusters, held together by shared context, shared taste, shared clarity, and shared system design. Leadership layers still exist, but their job changes. They are no longer approval bottlenecks. They become context routers, interface designers, and force multipliers. In that model, the CEO is not managing every pod. The CEO is designing the architecture that lets many pods move with coherence without rebuilding the old bureaucracy. That is what AI-native scale looks like: not a flatter pyramid, but a different system.
Once that happens, hierarchy stops being the main coordination mechanism. Context becomes the main coordination mechanism. The most important question is no longer "Who reports to whom?" It becomes "Who truly holds the context, and who has the judgment to act on it?"
That also changes what leadership layers are for. In the old world, a large part of middle management existed to translate, summarize, coordinate, and move information across functional boundaries. In the new world, those roles only remain valuable if they evolve into system builders, quality reviewers, talent coaches, and cross-pod integrators. The transmission-belt manager will steadily lose importance.
In one sentence, the AI-native organization is this: a network of small pods with high context ownership, supported by AI agents, aligned by shared judgment, and connected by lightweight interfaces rather than heavy hierarchy.
The Window to Rewrite the Company
If role rewrite leads to CEO rewrite, and CEO rewrite leads to org rewrite, then this is not a tooling upgrade. It is a company rewrite. So stop staring only at your AI stack. Look at your people. Look at your structure.
Ask the harder questions. Are your people still trapped in narrow translation roles? Are your best minds still preparing handoffs instead of making judgments? Is your org chart still built for the old PM-Designer-Developer-Tester chain? Are decision rights still too far away from the people who hold the real context?
Buying AI access is easy. Real transformation is harder. It means redesigning roles, pushing ownership into small pods, rebuilding infrastructure around agents, and redefining leadership itself.
The winners of this era will not just use better models. They will rebuild faster. They will replace handoff chains with pod networks. They will move context to the edge. They will raise the bar for judgment.
AI is not just rewriting tasks. It is rewriting the company. The window is open now. It will not stay open for long.