Chris Bee

Engineers aren't going anywhere.

AI coding gets you 80% of the way there, super fast. But the last 20% is where judgement lives: structure, architecture, and design that scales.

If your only moat is speed, you aren't building something durable.

Vibe coding has mostly replaced no-code tools.

The next question: does it replace the rest of software engineering?

If you read X, you’d think yes.
If you’ve actually shipped software, you know better.

Use AI as much as you want, but you own whatever it creates. You are the author, AI is the assistant.

If you’re entire job is sending emails and going to meetings you are ngmi.

AI is leveling the technical field. The next wave of builders will win on context, trust, and access.

You don’t need a new model. You need a reason for someone to say, “Yeah, let’s pilot that next week.”

The irony?
Most technical founders start with code and chase customers.
The ones with industry reach start with customers and never touch code until they've validated the need.

The real edge isn’t in prompt engineering, it’s in people engineering.
Who trusts you? Who picks up when you call?

If you’ve spent a decade in logistics, healthcare, insurance, you already have a company waiting to happen.

You know the pain points, the politics, and the budget holders.

Everyone’s chasing the next breakthrough in AI capabilities.
But that’s not where the moat is.

Every builder has access to the same models, same APIs, same speed of improvement.

What they don’t all have is distribution.

AI reflects your input. Feed it vague input, and expect refined chaos in return. Let's focus on clearer thinking, not better models.

Let's normalize finding time for family and hobbies and still being a startup founder. Life is for living.

When using an AI tool, people will generally wait up to 5 seconds for results without switching to another task. Anything longer belongs in the background. Respect the difference and present your UX accordingly. #buildinpublic

Foundational models will handle 80% of the work. The last 20%, the domain-specific specialization, is where trust and defensibility live. That’s where startups win.

AI isn’t here to take your job. It’s here to free you from trading hours for dollars. Abundance is possible, if you’re willing to lean in.

Devplan Next generation product development planning.

Forward deployed engineers aren’t just the future, they’re already here.
devplan.com gives modern engineers the context, clarity, and structured prompts to go from business intent to working code without the game of telephone. #buildinpublic

I think forward deployed engineers are going to be more and more common.

Not because they are better developers, but because they collapse the gap between what customers need and what gets built.

Context + ownership > tickets + handoffs.
#softwaredevelopment

Day 1: I'll just use ChatGPT for this PRD.

Day 47: Playing document detective across Notion, Asana, Trello, Jira, Monday, Slack, and Email, wondering what decisions were made and which version actually shipped.

Devplan Next generation product development planning.

ChatGPT is great for quick PRDs & brainstorming

Until chaos hits.
❌ Inconsistent docs
❌ Missing context
❌ Scattered copy/paste output

We're building devplan.com to give specs the structure + speed + context needed for today's AI workflows.

Devplan Next generation product development planning.

That last 20% is why we are building devplan.com
We feed in your company’s product docs, code, and workflows so the AI isn’t guessing. The result: specs, user stories, and tasks that are specific to your product and codebase, not generic boilerplate. #buildinpublic

Foundational models get you 80% of the way, but the last 20% is where accuracy and usefulness actually lives and that comes from context and specialization.

Why open ecosystems will win in the AI era:
- Agents need to talk to each other across platforms.
- Federated APIs = secure data sharing.
- Metadata standards = easy coordination.
- Protocols like MCP/A2A = common language.

The customer benefit: a single view of knowledge, not 10 partial ones.

- New market pace: Top startups are hitting $100M in 3-6 months(!), not years. Quarterly planning cycles is the furthest you want to plan ahead.

Biggest theme? Nobody knows exactly where this is going, but the pace is accelerating.

- AI task speed matters: Users should know if this will be a 5–10 sec task or background task. Mixing them breaks the UX.

- Incumbents vs startups: Incumbents win on distribution and data; startups win on speed and iteration. Both need agility.

- AI tooling split: Two camps are forming - pro tools (precision, control) vs vibe tools (speed, accessibility). Think Figma vs Canva.

- How to not compete with OpenAI: If it’s on the path to AGI or solving a short-term gap in model capability, they’ll build it. The opportunity is in verticals.

- Open > closed: Agent ecosystems need federated APIs, metadata standards, and protocols like MCP/A2A. Customers want unified insights, not silos.

- 80/20 rule: Foundational models will often handle the first 80%, but defensibility comes from the last 20% of domain-specific specialization.

AI is moving faster than anyone can keep up.

Yesterday at the IA Summit (thanks to Madrona for the invite!), I got to hear from top leaders at OpenAI, Atlassian, Amazon, Salesforce and more, and the message was clear: the rules of building are changing. Here were my takeaways:

The tools are incredible, but good software is still hard!

MCPs and rules files can help, sure. But only if you’ve already done the work to understand *why* you’re building something, what the system should do, and how you want to guide the model.

That clarity doesn’t come from a config file. It comes from you.

Good AI output still depends on the same things good software has always depended on:
• Clear intent
• Sound design
• The right context

Too many hype posts make it sound like there’s a single AI trick that’ll unlock perfect code.

There isn’t.

Stacking MCP servers, spinning up a dozen sub-agents, or obsessing over the “perfect” rules file won’t fix vague instructions or shallow thinking.