lgiordano_notte

Agree with this. Constraining generation with physics, legality, or even tooling limits turns the model into a search-and-validate engine instead of a word predictor. Closer to program synthesis.

The real value is upstream: defining a problem space so well that the model is boxed into generating something usable.

Shift feels real. LLMs don't replace devs, but they do compress the value curve. The top 10% get even more leverage, and the bottom 50% become harder to justify.

What worries me isn't layoffs but that entry-level roles become rare, and juniors stop building real intuition because the LLM handles all the hard thinking.

You get surface-level productivity but long-term skill rot.

Cursor’s doc indexing is acc one of the few AI coding features that feels like it saves time. Embedding full doc sites, deduping nav/header junk, then letting me reference @docs inline actually improves context grounding instead of guessing APIs.

LLMs shift the bottleneck - becomes less about typing code, more about spotting when something’s subtly wrong. Still need real judgment just applied to different layers. The skills that atrophy are surface-level. The deeper ones (debugging, systems thinking, knowing what not to trust) become more important.

Don't think the limit is in what LLMs can evaluate - given the right context, they’re good at assessing quality. The problem is what actually gets retrieved and surfaced in the first place. If the upstream search doesn’t rank high-quality or relevant material well, LLM never sees it. It's not a judgment problem, more of a selection problem.

Basically treating extraction as an adaptive loop instead of a static function. If first parse fails or looks incomplete, tweak the prompt, inject more context, or switch strategies. Memory helps carry forward partial wins so you don’t start from scratch. We’ve seen the same pattern in agentic web environments. Structured retries, context propagation, and memory turn brittle flows into robust automation, especially with high-variance input and fuzzy schemas.

Pretty cool. However truly reliable, scalable LLM systems will need structured, modular architectures, not just brute-force long prompts. Think agent architectures with memory, state, and tool abstractions etc...not just bigger and bigger context windows.

Value isn’t just the editor, it’s the workflow. Letting LLMs plan and act across multi-step flows is a hard problem, and Windsurf figured out a dev-focused version of that. Gains to be made in browser automation once you add structure, retries, and context. Feels like a bet on that pattern becoming default. But yeah as others said, highly doubt that's $3B in hard cash, more likely a roll-up of shares etc.

Really cool direction. The embedding-first + agentic verification pipeline resonates, similar pattern worked well for us in the web interaction space.

Shift isn't just about competitors gaining ground but about users increasingly bypassing traditional search entirely. Between Reddit, Perplexity, ChatGPT, and direct domain knowledge, more queries are being fragmented across tools that aren't indexed as 'search engines' but functionally serve that role.

In my experience the key friction point has been schema stability vs input variance. Had better luck treating mapping as a dynamic planning problem with retries and memory.

Agreed. Catching mismatches between doc and implementation is still valuable, just wouldn’t want people to rely on it as a safety net when the docs themselves might be inaccurate/incomplete. As a complement to traditional tests though seems like a solid addition.

A breakdown would be interesting. I can’t give you hard numbers, but in our case scaffolding was most of the work. Getting the model to act reliably meant building structured abstractions, retries, output validation, context tracking, etc. Once that’s in place you start saving time per task, but there’s a cost up front.

Curious how you're handling multi-step flows or follow-ups, seems like thats where MCP could really shine especially compared to brittle CLI scripts. We've seen similar wins with browser agents once structured actions and context are in place.

LLM-based coding only really works when wrapped in structured prompts, constrained outputs, external checks etc. The systems that work well aren’t just 'LLM take the wheel' architecture, they’re carefully engineered pipelines. Most success stories are more about that scaffolding than the model itself.