Skip to content
Linkdrop
Links

S03E01 · Mechanics Behind Product Engineering: MEGA lesson

A written lesson by MEGA about how product engineering changes as AI automates more of software development. It focuses on shifting from output to outcomes through ownership, judgment, systems thinking, and leverage.

textMEGA · hq.mega.dev · Saved Nov 19, 2026

mega course, product engineering, ai developer productivity, agent orchestration

Written lesson S03E01 of the MEGA.dev course, by MEGA. Agenda: Shift · Ownership · Judgment · Systems Thinking · Leverage. Its lesson video is presented by Kent C. Dodds and saved separately. (MEGA Student HQ, needs a login.)

S03E01 · Mechanics Behind Product Engineering

Even if language model development stopped today, it's reasonable to say there is no going back to manual coding and that we can build pretty much anything we want. But not everything, especially given what we've learned about building production systems that need to be reliable and efficient. What has changed is that our role isn't about writing code anymore. And if it's not, what is?

If we look at the software around us, we'll see that AI can replicate most of its features quite easily, even through reverse engineering. But getting the entire product right is something that can't be vibe coded with a couple of prompts, or even a fleet of agents. That's because it isn't just about writing code, designing the architecture, understanding the business, or making individual decisions. It's about doing all of this well, at the right time.

And that's where product engineering begins.

Outline

  • Shift: outcome over output, product engineer vs. product manager, attention as the bottleneck
  • Ownership: scope, user impact, business value, technical consequences
  • Judgment: assumptions, tradeoffs, taste, edge cases, uncertainty, consequences
  • Systems Thinking: architecture, dependencies, operational impact, system diffs
  • Leverage: AI-assisted exploration, looped prototyping, generative exploration, synthetic inputs

The Shift

Let's assume advances in generative AI continue to the point where the entire development process becomes autonomous. Agents can take on any requirement or issue and handle it well. They take care of quality, edge cases and performance, make good architecture decisions and even add the kind of polish many believe requires taste. To put it plainly: almost everything about our job gets automated.

What then?

Well, nobody knows this for sure, but if we think about it, when everyone can get almost anything they ask for, the difference comes from deciding what to build, how good the result will be, and how fast it can evolve. Besides that, there are things that cannot be generated by an LLM, such as real-world data, user base, clients or reputation.

Everything combined gives us a good product that can't be easily cloned. Because even if someone builds the same feature in a single day, they won't get our clients the same day. And it works the other way around too: if someone has the users, that doesn't mean they have our features.

A meeting-notes app used as an example. On the left, a loop of five stations runs clockwise around a circle: signal (38 teams ask for Notion export), decide (build Notion export, skip PDF), set the bar (keeps headings, links, tasks), build with agents (2 days, tagged easy to copy), ship and learn (71% of teams use it in week 1). The center says 1 turn: 9 days. Below, a row titled what the loop builds up has four cells: users 12,000, clients 340 teams, real-world data 1.2M meetings, reputation 3 years and a 4.8 rating. An arrow labeled grows goes from ship and learn to the row. An arrow labelled feeds goes from the row back to signal. On the right, a table titled a clone built in one day compares your product with a clone. Both have 24 features. The clone has 0 users, 0 clients, no real-world data, no reputation and 0 turns of the loop, and it picks its next feature as a guess. These clone values are red. A dashed gray arrow labeled the only part copied goes from build with agents to the clone column. All values are examples.

Open figure

For anyone already familiar with building products from more than just an engineering standpoint, all of this may sound like nothing new. There is a difference, though: velocity and adaptability. Both need to reach levels unlike anything we've seen before, not just in generating code but in every single aspect of product development. Today, adding a new feature to a product can be fast, but adding the right feature done well is an entirely different game.

There are a few reasons behind this, and one of them is that agents are becoming a proxy between users and apps. One example is Google Search, which many of us now use through agents rather than directly. Another example is ffmpeg, a tool that agents often use without even telling us. The same goes for Sentry, Resend, Parallel, Kitesurf, e2b, AgentMail, 1Password and many, many others. And all these are services and tools that can't be easily generated.

Left: a chat window that the user sees. It holds one request, "Cut 30 seconds from yesterday's demo and send it to Acme with the invoice.", and one answer, "Done. Sent to anna@acme.com with invoice #1042." A dashed line marked "hidden from you" separates the chat from a list of six agent calls: find Anna's address in past emails (Gmail), check Acme's billing details (Google Search), cut 0:42–1:12 from demo.mp4 (ffmpeg), rename and compress the clip (script written on the fly, dashed), create invoice #1042 (Stripe), and send the clip and the invoice (Resend). The list ends with "6 calls, 1 written on the fly, 41 s". An arrow labeled "1 request" goes from the user message to the first call. An arrow labelled "1 answer" goes from the last call to the agent message. Below is a scale from "easy to generate" to "cannot be generated" with three zones. "agent writes it": rename script, 12 lines, deleted after use. "faster to call": ffmpeg, 20+ years of codec work. "only way is to call", in red: Google Search, index of the web; Stripe, bank links, licenses; Resend, sender reputation; Gmail, your mailbox. All values are examples.

Open figure

All this suggests that software will be needed even in an agentic world, and the need for it will probably grow, because a single person won't have just one agent, but entire fleets of them. This raises a new set of challenges related not only to software, but also to hardware and most of the processes involved in building products. And those challenges are extremely exciting from an engineering perspective.

With this in mind, let's return to where we are today. What we've seen so far suggests that autonomy is already achievable in many areas, but it remains very demanding and runs into real technical barriers. Addressing them requires an understanding not only of the technology, but also of the broader context of the product. So the question is no longer "is the ticket done?" but "can the user now do what they need?"

That is the shift from output to outcome.

Ownership

Responsibility is one of the core aspects of our work because we care about quality, maintainability, scalability, performance, security and the countless details that go into delivering great software. Today, agents can handle most of these, but not entirely on their own, because we still need to make many critical decisions about the shape of the system.

In S02E02, we talked about agentic primitives, generalized building blocks, as a critical aspect of the architecture that opens the way to autonomous development and self-evolving software. Primitives, in practice, aren't just an engineering challenge, as a deep understanding of the domain, the product and the users is equally important.

A great example of this comes from Jediah Katz's talk about harnesses and Grok Bot. He presents Subscriptions as a primitive that lets the agents handle email, messaging apps, PR reviews, alerts and schedules. This single building block is enough for handling all of them, and anything else that we can subscribe to and that sends wake signals of any kind.

Five triggers (email to the bot, Slack mention, PR review, PagerDuty alert, weekday 9am) lead into a Subscriptions box that handles permissions, routing to the right agent, dedupe, noise filtering and waking the agent. On the right, a white drop-shaped agent mascot with an alarm clock, a bell, an envelope and a chat bubble. The agent sends subscribe(trigger) to Subscriptions, and Subscriptions sends wake(event) to the agent.

Open figure

The decision about the Subscriptions primitive seems obvious in this case. But if we look a little bit closer at features such as permissions, routing, dedupe, filtering and waking, and at the fact that this single primitive handles not just messaging apps but many kinds of sources, it becomes clear that whoever came up with it knew exactly what the broader picture of the entire product looked like. Judging by an architectural decision like this, they also seem to have had decent engineering experience.

While generalization in software engineering isn't anything new, it's easy to imagine that this feature started as a request to integrate our app with email and calendar. Without broader context, we as engineers might anticipate that there would be more than one integration and build some sort of gateway and adapters. Even though this would work, it would be a trap compared with the Subscriptions primitive, because it would lock us out of other types of composition.

One feature request, "integrate our app with email and calendar", splits into two lanes over four columns: week 1, month 2, month 4 and after 4 months. In the output lane, a gateway grows from 2 to 4 to 6 adapters (email, calendar, Slack, PR reviews, alerts, schedules). Each step takes 3, then 5, then 8 days, for 6 adapters to maintain and 16 days in total. In the outcome lane, one Subscriptions box of the same size takes 2, then 4, then 6 triggers through subscribe(trigger) / wake(event). The steps take 4 days, then 1 day, then 0 days, because the agent adds the last sources at runtime. The total is 1 primitive and 5 days. The product is an agent app, and all values are examples.

Open figure

Thinking in primitives clearly shows us the difference between output and outcome. The first led us to an implemented feature but added weight to the architecture, which quickly slowed us down. The second extended the product's capabilities while keeping the architecture lean and flexible. It also made adding new subscriptions so easy that agents can manage them at runtime themselves. In fact, this is one of Grok Bot's features.

All this does not come on its own and it requires additional effort, because it is much simpler to just implement the feature we were asked for. At the same time, finding a proper primitive requires us to take ownership and seeking additional context that may come from the business, users and our own research.

This may sound as if we're becoming product managers, but the difference between that role and a product engineer is that a product manager (PM) decides which problem to solve and why, while a product engineer (PE) decides what the product must do to solve it.

Heatmap of how much a product manager (PM) and a product engineer (PE) own each of eleven product areas. The areas are in two groups: Business and Engineering. The ownership levels are illustrative examples. Cells outside the overlap use neutral shades: the more ink, the more ownership. The PM is high on clients and users and on which problem to solve. The PE is high on what the product must do, edge cases, architecture, dependencies and operational impact. Four rows have red cells with a block pattern and a curly bracket labeled Overlap: business value, scope, user impact, and assumptions and tradeoffs. A legend shows the scale from none to high.

Open figure

The diagram above shows that product engineering isn't just about good primitives, but also about everything required to make them and the results we get once they're in place. Besides, this way of thinking applies not only to architecture decisions, but to nearly every single aspect of a product, with questions such as "should this feature exist?", "is this still needed?", "how can these features be combined?", "what brings the most value to users?" or "what makes users churn?"

And to be clear, we're not talking about changing our roles or rebuilding products from scratch, but rather about shifting the way we think, work, make decisions and build. We're talking more about a smooth transition, not necessarily an instant switch. Especially because most codebases and most products aren't ready yet for autonomous development.

During the transition, we may observe that:

  • The product becomes better aligned with users' actual needs and stays more competitive because it can adapt faster, thanks to better primitives and the system we build around it. That system takes care of quality not only in engineering processes, but also in other areas such as marketing and customer success.
  • Users start to notice that the product evolves faster than before and becomes more customizable and accessible, especially if we find a way to let their agents interact with it.
  • The codebase gradually becomes less complex thanks to proper generalization and the removal of features that can either be replaced with simpler ones or be easily retired. Moreover, agents will take over nearly every single process, because the environment we shape for them lets them reliably verify the results of their work and give us actual proof of it.
  • The business gets more tools to reach out to new clients and increase the lifetime value of existing users, which translates almost directly into healthier cash flow and new opportunities to maintain sustainable growth.

There will be many more signals revealing the effects of our work, and those signals will bring us new ideas and new challenges to solve.

Judgment

As engineers, we do know how to create good software. In many ways, AI has made this much easier, but at the same time, it has added many new components and changed many of the rules. Today we can process data in ways that weren't feasible 3 years ago, while features that were once valuable enough to build entire products around can now be generated by anyone.

Even though AI can write better code than most human programmers, our knowledge, experience and many of our skills are still useful, especially if we understand how engineering is changing because of the new possibilities we all have now.

Given the definition of a product engineer, we need to find a way to work much more broadly. That means reaching into other areas of the product and the business, or digging into low-level details or even technologies we are not familiar with. And while this may sound extremely difficult, most of the knowledge we need is one prompt away. We just need to learn how to explore unknown unknowns.

A two-by-two matrix. Columns: we know it, we do not know it. Rows: we are aware of it, we are not aware of it. The four cells are known knowns, known unknowns, unknown knowns and unknown unknowns. Unknown unknowns, in the bottom-right cell, is marked in red.

Open figure

Exploring an entirely new topic isn't easy when we don't know what we want to learn, or even where to look. But LLMs can do more than answer our questions. They may also suggest questions we didn't know we wanted to ask. On top of that, we can create a skill that tightens the feedback loop, so instead of throwing a wall of text at us, the AI guides us with short, well-phrased messages. And whenever we need it, the agent can give us a mind map or interactive artifacts presenting wireframes or proofs of concept.

A large mind map of an example topic, Offline mode, drawn only with curved lines and keywords. Nine branches spread left and right, and most have smaller branches. Two branches are red as high signal: Conflicts, with the note "parallel edits" and a proof-of-concept attachment, and Sync status, with the note "what users see" and a wireframe attachment. Solid lines show explored branches. Dashed lines show branches that are not explored yet. Small circles with counts such as +2 and +3 show collapsed branches. The topic and branch names are examples.

Open figure

In the same way, we can discuss and quickly iterate on database structures, primitives, or anything else that's useful to see from a broad perspective, with the option to zoom in on the details.

Agents can also help us understand the product and the features we're about to build, and make decisions about them. In this case, however, we can't rely on the model's base knowledge alone, and even the codebase often isn't enough, since it lacks the context needed to understand the decisions we have to make. That's why we discussed knowledge systems in S01E03: once we have them, we can spin up a couple of agents with different models to work together in T3 Code/Devin/Cursor or Herdr on an HTML document that presents the choices we have.

In such documents, we can ask the agents to use well-known decision-making tools such as a feasibility matrix, an Eisenhower matrix, a decision tree, or a pre-mortem analysis. Below is an example that presents features in terms of their value, complexity and risk, so either we or an agent can decide which of them to pick based on the available resources and the broader context.

A feasibility matrix with complexity on the horizontal axis and value on the vertical axis. A numbered square marks each feature, and its shade shows risk. The positions and risk levels are example values for one scenario: a request to integrate an app with email and calendar. 1 Email integration, 2 Calendar integration and 3 PR reviews integration have low complexity and low value. 4 Gateway and adapters has more complexity, little more value and high risk. 5 Subscriptions primitive, marked red, has high complexity, high value and medium risk. 6 New source as a subscription has low complexity, high value and low risk, because it is built on 5.

Open figure

Undoubtedly, we have many tools, and we can create new ones that are perfectly tailored to our needs. But good judgment isn't about getting things right the first time. It's about deciding what to do next so we uncover as many unknowns as possible, while using the resources we have efficiently and learning from what we've done so far.

AI lets us build things fast, but building for production is still hard, and getting it right takes time. As we'll experience sooner or later, having a fleet of agents working for us almost around the clock brings us new challenges, including those not strictly related to agents.

Leverage

Primitives, ownership, better architecture, proper context management, parallel agents and product engineering as a whole can get us to a place where development happens insanely fast. After S01E05 we also know that at the core of everything else is taking care of the environment that lets agents verify their own work.

But all of that can be useless... if we build the wrong thing.

There's a great quote from the book Getting Real, which says that "the best designers and the best programmers aren't the ones with the best skills or the nimblest fingers (...), they are the ones that can determine what just doesn't matter. That's where the real gains are made".

That book was written in 2006, but this part remains relevant and becomes even more important, as today we can move fast in the wrong direction. And while it's easy now to simply remove code, we can't easily roll back things that were already shipped to users, as here we're dealing with their trust.

The leverage we're looking for, especially when we want to move from working directly with agents to autonomous development, comes from getting the foundations right, such as:

  • Telemetry: it's hard to improve things we don't measure, and agents must receive detailed information about users' activities and everything we consider useful for them to know.
  • User feedback: if that's possible, we should seek direct contact with our users through customer support chat, calls or in-person meetings. Extremely useful context comes from analyzing bug reports and feature requests, but also from transcripts of calls with people who never became our clients.
  • Business context: getting the right primitives and their proper shape requires a deep understanding of the business objectives, its direction, challenges and even insights from the market.
  • Product analytics: telemetry isn't the only source of valuable information about the users. Product managers may have insights on user profiles, similar products or a broad perspective of the entire product.
  • Agent environment: everything we've discussed in S01E05, configured on remote machines or in the cloud. Without this, thinking about autonomy should be set aside until the complete environment and the essential details that give agents freedom are in place.
  • Labs: it's worth making a habit of creating simple labs for playing with ideas and iterating on concepts. These may be HTML and CSS apps that we work on through agents. Doing this will give us a quick understanding of the feature we want to build and let us share the concepts with others. It's similar to artifacts available in Claude for example, but a lab is built into the application we're building.
  • Beta channel: it is worth considering beta channels or nightly versions of the app, where updates are frequent and features may come and go. That's especially useful during the scaling phase of the development process.

In other words, getting real leverage requires us to look around and see what we can do with the systems, resources, and tools we already have, so we can prepare them both for higher velocity and for agents that will use them on behalf of users. And this must include not only the engineering context but also a broad product perspective.

Then, depending on our product and business, it's worth at least considering bold roadmap decisions, which in some cases may include building an entirely new version of the system. But more often, we'll want to design a plan that will gradually, and then suddenly, shift the product towards the agentic era and autonomous development—and that's where the real leverage will come from.

Takeaways

Developing the mindset of a product engineer helps us look at our roles much more broadly, beyond writing code, fixing bugs and implementing features. Even if the organization we're working in isn't ready for the shift yet, it's in our interest to start looking at our work from a broader perspective. This will let us see that autonomous development isn't the end of our jobs. It is another chapter.

Product engineering as a role isn't new, and there are many books on the topic worth reading. One of them is the already mentioned Getting Real, and others include Empowered, The Mom Test and Shape Up. I've read all of them, and even though they were written before the "ChatGPT era", they still carry valuable lessons for us engineers.