Crossing the Chasm - Skilling Up Product and Delivery
Jul 15, 2026 • 7 min read
Developers and Product Managers have a chasm to cross — from hand coding to agentic LLM work — and the early adopters are already ahead.
Listen to this post in the author's own voice
Over the past four years, I’ve been on a journey. At first, I didn’t even realize I had started, but looking back, it’s clear there was a huge divide, a barren desert, a grand canyon ahead of me — it must be crossed. I knew I had to do so eagerly if I wanted to continue to stay relevant in the new world of AI.
Even I still might not be across entirely at this point, and to be honest, I don’t know if I will ever make it across because the distance is expanding, rapidly day by day. I think that’s okay. The huge expanse is progress: the constantly evolving world of artificial intelligence and how that is shaping the way we build and deliver digital products.
What is this expanse? What is this huge divide? It is an entirely new skill set — from writing code and building products the old way, by hand, to handing all of the hard strokes and more control over to large language models. As Agent Smith said in The Matrix, I think this is an “inevitability.”
I say that as an engineering leader and as an individual contributor. It’s what I’ve observed across the board in multiple roles, and what I’ve had to learn myself even as I’ve struggled and walked into the void.
Getting Started
I started where a lot of others started: GitHub Copilot and tab completion. Helpful. Fast. Still basically me driving every line.
Then I moved into Cursor and started working in a more agentic way — ask it to plan first, revise the plan, then build. That changed the shape of the work. I wasn’t just accepting the next token. I was directing an agent through a loop.
As Claude Code evolved and became a dominant force, again, I dug in and shifted my focus from the IDE into the command line and the terminal. This is familiar territory for me, with years of experience. As a systems administrator, the terminal was my home. Working with Claude Code offered the same opportunity to plan and build, but I started digging harder into how to set things up so the output was deterministic and reliable. Across Claude Code, Cursor, and other tools, that meant learning the boring-looking stuff that actually pays off:
- Mastering Claude Code, Cursor, and how the underlying models behave
- Establishing repeatable context through markdown files
- Skills, Rules, MCP servers, Loops
- Claude settings
- Design guidelines
- Frequent updates to all of the above to fine-tune over time
That has been the real payoff for me. Understanding how to manage and wield the tooling on top of the LLM — not just chatting with a smart model — is the skill.
Models like Claude Fable make this hard to ignore. The capabilities are there to replace writing code by hand. The question is whether we are on the journey to wield these tools — whether we are willing to cross to the other side.
Crossing The AI Chasm
A popular marketing and product book that almost everyone has read, or at least should read at this point, is Geoffrey Moore’s Crossing the Chasm. The book describes the gap between the early market — people who want the newest thing and will live with a minimum feature set — and the mainstream market — people who want a complete solution and convenience. That gap is the chasm. A lot of products die in it.
Crossing the Chasm — technology adoption curve with the gap between early adopters and the early majority
Like a successful product in the market, developers and product managers also have a chasm to cross if they want to remain relevant and have the valuable skills needed to succeed in the coming years.
On one side is the old way of writing software. On the other is the new way — agentic work with LLMs, set up so the output is consistent and reliable. The journey I crossed isn’t something to be taken lightly. It must be started. Progress must be made every day. Right now the early adopters are ahead. And the chasm is getting wider as the models and agentic harnesses improve. Off in the distance on the other side are developers who went through the learning curve and are well on their way.
They adopted early. They experimented often as the models changed. They put in the work to battle through prompting — the awkward phase where the tools feel uneven and it’s tempting to quit. Then they elevated past prompts alone. They learned how to configure the environment. How to set context. How to build workflows and skills that produce deterministic output in an efficient way.
That is the real mastery: harnessing LLMs so the work comes out better than it ever did by hand.
I still understand that in some cases hand-coding is the right call. Those cases are getting fewer and further between. Crossing the chasm is not an excuse to skip the craft — I’ve written about why hard skills keep me in the driver’s seat. Fundamentals are what let me know when the model is wrong. The chasm is about how I work day to day, not about abandoning the ability to drive.
Pressure From Non-Technical Builders
Here is the part a lot of developers might not see coming, but it is coming quickly.
Non-technical, but determined product, marketing, and design teams are no longer fenced in because they don’t know how to code. They are now enabled to build and release software without a developer. The huge hurdle of learning code syntax and architecture is handled by an extremely capable LLM — especially if someone has technical inclinations but lacks the years of experience. If these individuals are determined to research, ask the right questions, and let Claude guide them, they can build things that would not have been possible before, without a developer.
That closes the gap between what a developer could offer an organization in the traditional sense and what a non-technical product manager or marketing person can ship. It depends on the individual. Always has. But the floor moved.
There is still a technical craft in managing LLMs properly. That is where developers should focus now — not on the trivia of every line of code, and definitely not on poo-pooing the tools while insisting the old way is still the path.
Product managers have a version of this too. The idea that things can be built quickly with LLMs has already closed delivery timelines. What I am not seeing enough of is PMs producing the technical artifacts that used to eat their calendar — PRDs, user stories, the revision loops that made that work tedious. Same as writing code: with the right skill and project setup, those artifacts do not take that much time anymore.
A team that produces good user stories, ingests context, and hands work off cleanly to engineering is what product managers should be aiming at. They need to learn the technical skills of their own craft. AI is encroaching on their space as well.
Same story for product designers. Producing high-quality designs by hand is no longer the whole job. Producing deterministic designs — managing that process so the output is consistent — is a skill. They have a chasm to cross too.
The Handoff is The Product
Developers still have an upside here. They are the technical staff. But the biggest lever for an organization that wants to build faster and more efficiently with AI is not a better autocomplete in the IDE.
It is the whole product and delivery pipeline.
I’ve written before about the minimum viable team — product manager, product designer, developer. One of each. That trifecta still holds. The work that matters now is managing the handoff across it so context can move — from the LLM on the product and product design side into the context and LLMs on the development side. PRDs, stories, design decisions, constraints: all of it needs to transfer cleanly, not get re-explained from scratch in a chat window three weeks later.
If only engineering and delivery cross the chasm, the org is still stuck mid-gap. The whole pipeline needs to be managed agentically to speed up delivery and scale in an age of AI. A chain is only as strong as its weakest link.
So Cross
Writing good code is table stakes. In most cases, writing it by hand is probably not needed anymore. The skill worth learning is how to produce reliable work from tools that are not reliable by default — and how to set up a team so that work survives the handoff from product to delivery.
I’m not putting my head in the sand. I’m not poo-pooing the models before putting in the reps. I’m not treating the IDE as the whole game.
I experiment. I set context. I build workflows that make the output repeatable. I help product and design do the same. I work to get the handoff right.
The chasm is getting wider. The people who already crossed are not waiting for anyone.