<![CDATA[Forward Deployed]]>https://www.forwarddeployed.comhttps://substackcdn.com/image/fetch/$s_!xznZ!,w_256,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff2fc53ef-d888-4b36-9a31-95961074ba5e_178x178.pngForward Deployedhttps://www.forwarddeployed.comSubstackWed, 13 May 2026 11:48:38 GMT<![CDATA[Forward Deployed, Episode 5: Aligning Agents]]>https://www.forwarddeployed.com/p/forward-deployed-episode-5-aligninghttps://www.forwarddeployed.com/p/forward-deployed-episode-5-aligningThu, 07 May 2026 13:37:11 GMTWelcome to episode five of Forward Deployed. Noah sits down with Taylor Pearson to continue the conversation about how we align agents, and why the best models may come from outside traditional software engineering.

Taylor brings a background that cuts across history, internet businesses, The End of Jobs, risk parity investing, complexity science, and recent deep work with Claude Code. The conversation moves from firms and transaction costs to Toyota, military doctrine, memory, skills, and the problem of getting agents to work toward the right goal.

Key Topics Covered

  • Aligning agents: Why the episode starts with the question of how to align agents and what engineering can borrow from organization design, markets, and systems theory

  • Taylor’s path: From history, SEO, ecommerce, and The End of Jobs to finance, risk parity, complexity science, and AI work

  • Claude Code as a turning point: Why agentic command-line systems felt more transformative for Taylor than chatbot workflows

  • Historical analogies for AI: Electricity, factory design, Toyota, and the need for a new pattern language for agentic work

  • Companies as agentic systems: Why firms may be a more useful model than deterministic software systems for coordinating agents

  • Junior employees and agents: The familiar failure mode where the work is done well but aimed at the wrong problem

  • Bottlenecks and specs: Why fixing pull requests is not the whole game, and why the bottleneck may move upstream into briefs, specs, and coordination

  • Pace layers and skills: Best practices, project architecture, plans, code, and how different layers of a system move at different speeds

  • Memory and context: How skills, files, and externalized memory help agents carry useful context between sessions and systems

  • Jobs and firm boundaries: How AI changes the calculus around what belongs inside a company, what gets outsourced, and which roles collapse together

  • Writing, investing, and complex systems: Why some domains resist fixed best practices because everyone adapts to the same patterns

Timestamps

Note: timestamps are approximate

  • 00:00 - Introduction: Taylor Pearson, complexity theory, organizations, and aligning agents

  • 01:15 - Taylor’s path from history to SEO, ecommerce, The End of Jobs, finance, and AI

  • 03:30 - The GFC, The Black Swan, markets, systems thinking, and transaction costs

  • 07:00 - Claude Code, Codex, and the agentic workflow shift

  • 13:45 - Historical analogies for AI, electricity, factories, and pattern languages

  • 18:00 - Why companies may be the better model for agentic systems than software systems

  • 20:45 - Organization metaphors, the Toyota Production System, and agents as junior employees

  • 24:00 - Bottlenecks, specs, briefs, and the coordination work before code

  • 27:05 - Mission alignment, pace layers, skills, best practices, and architecture

  • 32:20 - Cynefin, best practices, good practices, and emergent practices

  • 34:50 - Boyd’s OODA loop, Schwerpunkt, and shared objectives

  • 39:05 - Memory, role boundaries, and what changes inside and outside the firm

  • 43:25 - Externalized memory, skills, and context across systems

  • 46:25 - Generalization, AI writing, de-slopping, and verifiable rewards

  • 49:15 - Writing, investing, complex systems, and the Maginot Line problem

  • 51:20 - Closing thoughts

Links & References

Core References

Concepts & Frameworks

Tools & Platforms

  • Claudesidian - Noah’s Obsidian/Claude framework

  • OpenAI Codex - The competing agentic coding interface discussed in the episode

  • Obsidian - Note-taking and memory system context for agent workflows

  • Alephic - Noah’s AI consulting company

Previous Episodes

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands and enterprises build custom AI systems.

Taylor Pearson is an author and investor whose work spans entrepreneurship, markets, complexity theory, and AI. He is the author of The End of Jobs.

Connect with the Hosts

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

Newsletter: Sign up for updates at forwarddeployed.com

]]><![CDATA[A Timeline of AI Progress]]>https://www.forwarddeployed.com/p/a-timeline-of-ai-progresshttps://www.forwarddeployed.com/p/a-timeline-of-ai-progressTue, 05 May 2026 16:46:28 GMTI originally put this slide together for the September 2025 edition of BRXND. It is a timeline of what I would consider the major milestones in AI over the last five years. The orange ones are the things I think are worth paying attention to. It was designed to scale as best I could with my limited Figma skills.

There are two things that should stand out:

Thanks for reading Forward Deployed! Subscribe for new posts and episodes at the intersection of AI, engineering, and the enterprise.

  1. There are fewer moments than you would assume over the last five years. That’s because I purposely left out every small model update and focused on the bigger events.

  2. There are only five highlighted moments. Despite arguments to the contrary and the never-ending parade of model releases, I genuinely believe AI has undergone only a few major changes over the last five years.

My five moments with their defenses:

  1. November, 2021—GPT-3 API goes GA: This one is easy for me. We could draw the line in the sand almost anywhere after the Attention is All You Need paper, but to me, putting these things in the general public’s hands (albeit in API form) is a good demarcation point. There are still the “I’ve been doing AI for years” people complaining that ML is AI, but what’s possible before and after the GPT-3 API is very different.

  2. June, 2022—GitHub Copilot goes GA: it’s easy to take for granted now, particularly with the conversations happening around uptime and GitHub, and the eventual direction Microsoft took the Copilot brand, but that initial autocomplete product in VS Code felt like magic and was the first real productization of AI.

  3. November, 2022—ChatGPT Launch: This is the easiest one, and everyone likes to talk about it. Lots of us were building chatbots on our own, and this felt like such an obvious next step. Funny enough, this also immediately shifted Copilot use because while autocomplete was cool, chat turned out to be the killer app for coding (a fact Copilot seemed to miss and Cursor eventually ate their lunch on).

  4. September, 2024–o1 Reasoning: The Google chain of thought paper came out in early 2022 and showed that adding reasoning to prompts significantly improved the models’ ability to reason, but it took two and a half years for OpenAI to build it into a model. o1 was big and slow, but set the groundwork for everything that followed. Though we didn’t realize it at the time, the real magic of these reasoning models wasn’t just that they were much better thought partners. Function calling was introduced to models in June 2023, but before reasoning models, it was incredibly inconsistent—better for demos than for real work. Reasoning changed that, allowing the model to plan its function calls before executing them.

  5. May, 2025–Claude Code: finally, we have Claude Code, which celebrates its first birthday this month. If o1 made function calling work, Claude Code wrapped it in an agent loop: inspect the repo, decide what to do next, call a tool, read the result, and keep going. The tools themselves were simple UNIX commands, deeply covered in the pre-training data thanks to half a century of UNIX documentation. While lots of people believe that Opus 4.7 unlocked the harness, I think the causality goes the other way.

Despite how easy (and fun) it can be to get lost in each new model release or tool update, the reality is that most of it is just gradual improvement. That’s not to say it’s not tremendously valuable—GPT 4o unlocked ChatGPT in new ways—but those weren’t step changes in what is possible, they were the kind of slow progress that we always find hard to measure.

To that end, I have a few observations and thoughts from this list.

First off, each of these step changes is still very much building on the previous one. ChatGPT doesn’t happen without GPT-3, just like Claude Code doesn’t happen without o3. Reasoning models themselves are obviously evolved from prompting techniques. That can make AI progress feel Darwinian, but W. Brian Arthur’s point in The Nature of Technology is more specific: technologies evolve by combination. New things are assembled out of existing components and the phenomena they harness; sometimes better variations win, and sometimes a new principle arrives that makes the old family tree less useful. The jet engine isn’t just a better propeller. His focus is mostly hardware, not software, but it still makes me wonder if we should expect more radical changes, or maybe we’re just settled into this architecture, and that’s how we should expect innovation to happen. Here’s how Anthropic co-founder Jack Clark put it recently:

As a field, AI moves forward on the basis of doing ever larger experiments that utilize more and more inputs (e.g, data and compute). Every so often, humans come up with some paradigm-shifting idea which can make it dramatically more resource efficient to do things - a good example here is the transformer architecture and another is the idea of mixture-of-expert models. But mostly the field of AI moves forward through humans methodically going through some loop of taking a well performing system, scaling up some aspect of it (e.g, the amount of data and compute it is trained on), seeing what breaks when you scale it up, figuring out the engineering fix to allow it to scale, then scaling it again.

Another interesting observation is that image and video models are mostly missing on this timeline. I don’t quite know what to make of these models, and that’s part of the reason I’m writing this post. Every time a new step change in capability comes along (like Nano Banana or, more recently, GPT Image 2.0), we see people say everything is going to change, and then mostly not a lot changes. As practitioners of AI and marketing, we are making good use of the current crop of models with a variety of customers for a variety of use cases, but it feels like the Copilot/ChatGPT/Claude Code moment just hasn’t arrived yet. Obviously, diffusion as an approach is amazing and probably deserves a place on the list, but the leaps feel much more gradual and make it hard to draw conclusions. With all that said, the release of GPT Image in March 2025 caused an explosion of usage in ChatGPT.

To that point, maybe the most fundamental takeaway from the timeline is that the real leaps in usage come from a kind of weird alchemy between model, market, and harness. The model has to be good enough to do the job, the harness has to expose that capability in a form people can actually use, and the market has to be in the right place to see the full value. Each one of these episodes caused a step change in token demand. Anthropic’s own annualized run-rate numbers make the point: the company went from approximately $9 billion at the end of 2025 to more than $30 billion by early April 2026.

Sholto Douglas, an Anthropic researcher focused on scaling reinforcement learning, made a version of this point on a 2025 episode of the Dwarkesh Podcast: Cursor had been around for a while, but with Claude 3.5 Sonnet, “the model was finally good enough that the vision they had of how people would program, hit.”

That’s why the causation is so hard to pin down. Lots of people are sure that Claude Code exploded in December because of the release of Opus 4.7. As a relatively early adopter of CC, I’m a lot more skeptical. Many of us were getting tremendous value out of the harness in June and July. I think it’s much more likely that the real thing that happened in December is that a bunch of people just had more time to give the tool an honest go, and when they did, they were blown away.

Claude Code creator Boris Cherny calls this “product overhang.” The model’s capabilities often remain untapped until the right code comes along to unlock them. What I think this timeline adds is that there is a market overhang, too. The model can be good enough, and the harness can exist, but the market also has to be ready to notice, care, and change behavior. The highlighted moments are when model, harness, and market meet.

So what comes next? I don’t know. The three things I keep coming back to are reliable computer use, secure mobile agentic capability, and real document collaboration. I don’t know if any of them are the thing, but they all feel like potential unlocks for the next step change in token demand.

Thanks for reading Forward Deployed! Subscribe for new posts and episodes at the intersection of AI, engineering, and the enterprise.

]]><![CDATA[10 Links for Saturday, May 2]]>https://www.forwarddeployed.com/p/10-links-for-saturday-may-2https://www.forwarddeployed.com/p/10-links-for-saturday-may-2Sat, 02 May 2026 13:50:21 GMTYou’re getting this email as a subscriber of ForwardDeployed, a newsletter at the intersection of AI, engineering, and the enterprise.

Subscribe now


Looking for something to read this weekend? Here’s 10 quick hits:

  1. Taylor Pearson (who will be on the next episode of the podcast with me) uses Goldratt’s The Goal/theory of constraints to question parallel agent usage: “I suspect a lot of agent usage right now is the same fallacy at higher resolution. Running 20 Claude Code sessions in parallel can feel productive because something is always happening. But, if the bottleneck in your work is judgment about what’s worth doing, more agents just generate more output for you to wade through.” (If you haven’t read The Goal, it’s highly recommended. There’s even a graphic novel version.)

  2. GitHub’s Maggie Appleton hits on a point I’ve been making a lot: We’ve known code wasn’t the bottleneck for 50 years (see: Mythical Man Month) … “Implementation is rapidly becoming a solved problem, right? Writing code is now fast, it’s getting cheap, and quality is going up and to the right. The hard question is no longer how to build it. It’s should we build it.”

  3. Codex Desktop is very good. Flue looks intriguing: “Not another SDK. Build powerful, autonomous agents with Flue’s programmable TypeScript harness. Write once, deploy anywhere.”

  4. Very worth reading the Claude Code postmortem from Anthropic. Lots of lessons about the way small changes can impact agentic systems.

  5. Interesting to track some of the follow-ups to the Jensen/Dwarkesh conversation. I particularly liked this ChinaTalk piece.

  6. It’s cool that OpenAI released this little PII redaction model.

  7. I’d love to see DESIGN.md catch on … curious to see what happens.

  8. Steve Yegge (of Stevey’s platform rant fame) punched back when Google folks said he was wrong about internal usage of Gemini models. No clue what’s real/not real here, but following the way the Mag7 is using AI and how different each company’s approach is is fun to watch.

  9. I’ve been thinking a lot about my variance spectrum concept recently and how it relates to the spectrum of testing, linting, acceptance criteria, etc., that we integrate into agentic workflows. I put up a page to cover off on the basics, as it’s a model I continue to come back to.

  10. Aligned agents still build misaligned organizations, from Rohit Krishnan (coming on the podcast soon) is fun. “So while each role did things that made sense to them, they ended up in a spot where they’re clearly misleading folks. The headline failure here is that the company’s billing system ends with the SLA clock stopped when the underlying world clearly says the outage stayed past the trigger when credit and review should have opened. (That is the value the billing system would return to say, an auditor.)”

That’s it for now. Have a great weekend.

— Noah

Thanks for reading Forward Deployed! Subscribe and share.

]]><![CDATA[Forward Deployed, Episode 4: The Special Forces Model]]>https://www.forwarddeployed.com/p/forward-deployed-episode-4-the-specialhttps://www.forwarddeployed.com/p/forward-deployed-episode-4-the-specialSat, 21 Mar 2026 20:59:34 GMTWelcome to episode four of Forward Deployed. Noah sits down with Chris Papasadero to explore the deep parallels between Special Forces operations, enterprise software deployment, and creative direction—and what all of it means for building AI agents that actually work in the real world.

Key Topics Covered

  • The Forward Deployed Engineer (FDE) model: How Palantir’s approach to embedding technical experts mirrors Special Forces doctrine

  • Force multiplication: Why Green Berets are designed to produce outsized output from minimal input — and what that means for AI agents

  • Comfort with ambiguity: The Special Forces selection pipeline, the Star Course, and why a 2% selection rate tests for the right traits

  • Cultural embedding: Why Palantir contractors in Afghanistan succeeded by understanding the operational environment, not just the software

  • Organizational structure and bureaucracy: NCO-led detachments, pushing planning to the lowest level, and the OSS Simple Sabotage Field Manual

  • Three layers of alignment: Shared cultural values, doctrine, and experience — Chris’s framework for aligning both teams and AI agents

  • Second and third-order effects: Why software engineering (like warfare) is a creative pursuit, not a six sigma factory process

  • Showrunners and creative direction: The role of holding both operational and creative vision across a large, autonomous team

  • Warhol Factory vs. Ford Factory: Why creative production is a better analogy for agentic systems than industrial automation

Timestamps

Note: timestamps are approximate

  • 00:00 - Introduction and the origin of “Forward Deployed”

  • 01:30 - Chris’s background: Special Forces and Palantir

  • 05:00 - The Forward Deployed Engineer (FDE) model at Palantir

  • 08:30 - Cultural embedding: Why Palantir worked in Afghanistan

  • 12:00 - Special Forces as force multipliers

  • 15:00 - The selection pipeline and comfort with ambiguity

  • 18:30 - The Star Course: Navigating alone without external guidance

  • 21:00 - Maintaining the big picture in the fog of war

  • 25:00 - Organizational structure: NCO-led detachments and decentralized planning

  • 29:00 - Planning for failure: Incorporating contingencies from the start

  • 33:00 - The Simple Sabotage Field Manual and organizational bureaucracy

  • 37:00 - Applying military frameworks to AI agents

  • 41:00 - Three layers of alignment: Values, doctrine, and experience

  • 45:00 - Second and third-order effect analysis

  • 49:00 - Software engineering as a creative pursuit

  • 52:00 - Showrunners, dailies, and creative direction

  • 56:00 - The Warhol Factory model for agentic systems

  • 59:00 - Wrap-up and key takeaways

Links & References

Core References

Concepts & Frameworks

  • Special Forces (Green Berets) — Force Multiplication doctrine

  • The Star Course — Special Forces land navigation assessment

  • NCO-led detachments — Decentralized command and planning

  • Andy Warhol’s Factory — Creative production model

Related Content

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands build custom AI systems. He writes about AI strategy and implementation.

Chris Papasadero is this episode’s guest, bringing deep experience at the intersection of Special Forces operations, defense technology, and enterprise software deployment.

Connect with the Hosts

Noah Brier: LinkedIn | X/Twitter

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

]]><![CDATA[Forward Deployed, Episode 3: Context Engineering]]>https://www.forwarddeployed.com/p/forward-deployed-episode-3-contexthttps://www.forwarddeployed.com/p/forward-deployed-episode-3-contextSat, 27 Dec 2025 00:10:17 GMTWelcome to episode three of Forward Deployed. Noah and Lance dive deep into context engineering—the art and science of filling context windows with just the right information for agents to take the next action.

Key Topics Covered

- Context engineering: Why Karpathy’s term matters more than prompt engineering for agents

- Three core techniques: Reducing context, isolating context, and offloading context to file systems

- Skills vs MCPs: Why progressive disclosure beats loading everything into context

- Claude Diary: Building agent memory through reflection and evolving CLAUDE.md

- Why subagents should isolate context, not anthropomorphize org charts

- Production patterns from Manus: Compaction, file system offloading, and sandbox architecture

- The convergence of agent primitives: Read, write, reduce, and recombine

- Why treating agents like humans works: Dual-use tools and new coworker onboarding

Timestamps

- 00:10 - What is context engineering and why should we care?

- 00:37 - Karpathy’s definition: Filling context windows with just the right information

- 01:15 - Context engineering vs prompt engineering: Tools bring context too

- 02:27 - Three buckets: Reducing, isolating, and offloading context

- 04:30 - Dynamic context loading: Skills as just-in-time context

- 06:38 - Skills as context offloading: Progressive disclosure of tools

- 09:15 - Sandboxes beyond Manus and Claude Code: Application integration patterns

- 12:12 - Context isolation through subagents: Not org charts

- 14:41 - Using isolation as a feature: Test-driven development with blank slate agents

- 16:33 - Real-world subagent challenges: Shared file systems and context bottlenecks

- 20:47 - Claude Diary: Automatic memory through session reflection

- 22:53 - CLAUDE.md bloat: Reducing unnecessary words like Strunk and White

- 28:06 - Dual-use tools: Why Claude Code uses bash, grep, and human-readable commands

- 31:02 - Skills discovery problems: From manual search to automated finding

- 34:22 - Agent primitives: Read, write, reduce, and creative recombination

- 36:32 - Tool search and action space design: How to find the right function

- 40:50 - Hooks as determinism: Injecting code into agent loops

- 41:41 - Skills everywhere: ChatGPT’s progressive disclosure discovery

- 43:12 - Nano Banana: Text on images unlocks new agentic workflows

Links & References

Core References

Technical Resources

Tools & Frameworks

Related Content

- 🎙️ Karpathy on Dwarkesh Podcast - Discussion of AI development principles

- 📚 The Elements of Style by Strunk and White - “Reduce unnecessary words” as principle for CLAUDE.md

- 📄 The Bitter Lesson by Richard Sutton - General methods that leverage computation

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands build custom AI systems. He writes about AI strategy and implementation.

Lance Martin is a founding engineer at LangChain, where he works on developer tools for building AI applications.

Connect with the Hosts

- Noah Brier: LinkedIn | X/Twitter

- Lance Martin: LinkedIn | X/Twitter

* * *

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

]]><![CDATA[Forward Deployed, Episode 2: Claude Code Skills and the Progressive Disclosure Problem ]]>https://www.forwarddeployed.com/p/forward-deployed-episode-2-claudehttps://www.forwarddeployed.com/p/forward-deployed-episode-2-claudeMon, 17 Nov 2025 03:26:07 GMTWelcome back to episode 2 of Forward Deployed. This week Noah and Lance dive deep into Claude Code skills, a deceptively simple feature that’s changing how we think about building AI agents. Noah walks through the Alephic CLI he’s been building and reveals a wild hook-based routing system using Cerebras at 3,000 tokens per second.

Plus: Why Andreessen thinks AI isn’t the Internet redux.

Key Topics Covered

  • Claude Code skills and the progressive disclosure problem

  • How Noah built a hook to solve the 10% skill hit rate

  • Tier 1 vs Tier 2 action space: Why Manus and Anthropic converged on the same architecture independently

  • 3,000 tokens per second: Using Cerebras Llama 120B as an invisible routing layer for every user message

  • The MCP/skill/command convergence: Are they all just different flavors of the same primitive?

  • Vision feedback loop: Turning Gemini into a Pentagram creative director to critique Claude’s web designs

  • Andreessen’s “computers v2” thesis: Why AI isn’t the Internet redux, it’s the first von Neumann architecture replacement in 80 years

  • Git workflows with Claude Code: Why Lance and Noah don’t worry about merge conflicts anymore

Timestamps

  • 00:11 – Welcome to episode 2 on Claude Code skills

  • 00:28 – What are Claude Code skills? Not much more than a folder full of prompts

  • 01:10 – Lance: Skills as “instructing a new hire” with subfolder instructions

  • 01:25 – Simon Willison and Jesse Vincent’s “superpowers” discovery

  • 04:45 – Noah demos the Alephic CLI skill directory structure

  • 07:32 – The hook-based skill search system using Cerebras

  • 08:19 – Lance reveals: YAML front matter always loads into system prompt

  • 09:32 – The 10% skill hit rate problem when you have 10+ skills

  • 10:08 – Cerebras Llama 120B running at 3,000 tokens per second for invisible routing

  • 13:17 – The universal pattern: Everyone’s trying to control context

  • 15:59 – Tier 1 vs Tier 2 action space: Manus and Anthropic converge independently

  • 21:29 – Noah’s big challenge: Getting models to consistently look for skills

  • 28:04 – Hit rate drops to 10% even with only 4–5 skills

  • 30:54 – Could progressive disclosure become built-in like chain of thought?

  • 34:06 – Lance on externalizing context to file systems

  • 35:15 – Vision feedback loop: Gemini as Pentagram creative director critiquing Claude’s designs

  • 37:57 – Andreessen: AI isn’t the Internet, it’s computers v2

  • 42:08 – Why Noah and Lance don’t worry about merge conflicts anymore

Links & References

Core References

Tools & Frameworks

Blog Posts

Companies Mentioned

  • Anthropic – Claude Code creator

  • LangChain – Where Lance is a founding engineer

  • Alephic – Noah’s AI consulting company

  • Pentagram – Design agency Noah used as creative director persona

Development Tools

  • Obsidian – Note-taking use case for Claude Code

  • Git Work Trees – How the team manages multi-branch development

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands build custom AI systems. He writes about AI strategy and implementation.

Lance Martin is a founding engineer at LangChain, where he works on developer tools for building AI applications.

Connect with the Hosts

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

]]><![CDATA[Forward Deployed, Episode 1: The Bitter Lesson]]>https://www.forwarddeployed.com/p/forward-deployed-episode-1-the-bitterhttps://www.forwarddeployed.com/p/forward-deployed-episode-1-the-bitterMon, 03 Nov 2025 14:15:06 GMTWelcome to the first episode of Forward Deployed (YouTube), a podcast exploring the intersection of AI, software development, and the enterprise.

We’re very excited to have you join us as we tackle the wild world of Forward Deployed engineering. We hope to make this a roughly bi-weekly show and look forward to inviting guests in the future. The idea is to dive deep into the realities of making this stuff work in companies, building on our expertise as builders both inside and outside the enterprise.

Thanks for listening, and please let us know what you think.

Thanks,

Noah & Lance

Subscribe to Forward Deployed to be the first to hear about new episodes and articles.

In this inaugural episode, hosts Noah Brier (Co-founder, Alephic) and Lance Martin (Founding Engineer, LangChain) dive deep into one of AI’s most controversial ideas: The Bitter Lesson. They unpack Richard Sutton’s famous essay, debate whether LLMs truly follow its principles, and explore what this means for anyone building with AI today.

Watch on YouTube

Key Topics Covered

  • The Bitter Lesson: Why more compute beats clever algorithms (or does it?)

  • Richard Sutton’s surprising take on why LLMs aren’t “bitter lesson pilled”

  • The evolution from CNNs to transformers through Lance’s journey from Stanford to Uber’s self-driving program to LangChain

  • Chain of thought prompting vs reasoning models - why your prompts might be breaking

  • The real challenges of enterprise AI adoption

  • Why ICs are adopting AI faster than managers

  • Building for imperfection: Why optimizing for today’s models is a mistake

Timestamps

  • 00:00 - Introductions and backgrounds

  • 00:53 - Lance’s journey: Stanford PhD to Uber self-driving to LangChain

  • 02:49 - Noah’s path from marketing to AI obsession

  • 04:04 - What “forward deployed” really means

  • 09:04 - The Bitter Lesson explained

  • 11:31 - Why Sutton thinks LLMs aren’t following the bitter lesson

  • 23:09 - Chain of thought prompting and the reasoning model revolution

  • 24:19 - Building for future models, not current ones

  • 45:20 - ICs vs managers in AI adoption

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company working with enterprise clients like PayPal, EY, Meta, and Amazon on AI-powered content intelligence and competitive analysis. Previously founded and sold Percolate (marketing tech). He also runs the BRXND conference series focused on marketing and AI.

Lance Martin is a founding engineer at LangChain with a PhD from Stanford. Former computer vision lead for Uber’s self-driving truck program.

Links & References

Core References

Related Podcast Appearances

Blog Posts from the Hosts

Connect with the Hosts

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

Newsletter: Sign up for updates at forwarddeployed.com

]]>