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.
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.
Treating docstrings as the spec and asking an LLM to flag mismatches feels promising in theory but personally I'd b wary of overfitting to underspecified docs. Might be useful as a lint-like signal, but hard to see it replacing real tests just yet.
If you outsource that to a model, you often end up with words but shallow or no understanding. Writing forces you to clarify your ideas.
LLMs substitute genuine thinking with surface-level prose, which might sound alright but often lacks depth behind it.
Looks really cool.
Curious how you're handling action abstraction?
We've found that semantically parsing the DOM to extract high-level intents—like "click 'Continue'" instead of 'click div#xyz' helps reduce hallucination and makes agent planning more robust.
In trying to live an intellectually rich life, there's a risk of adding too much noise. Chasing more input, more ideas, more learning.
Sometimes less really is more.
Depth often comes not from adding, but from subtracting. Clear away the noise, and what’s left tends to have 'meaning'.
Personally I prefer a deep life to a rich life, but maybe that's just semantics...
Makes sense that verbal ability would line up more with success in CS, especially when math scores are already high across the board. A lot of programming leans on language-type skills: reading and understanding code, navigating docs, naming things clearly, writing maintainable logic etc.
The field probably does itself a disservice by overemphasising math. That framing can push people away who might actually do really well, especially those strong in reasoning, abstraction, or communication. Linked study is a good reminder to rethink how we present programming imo.
i wonder how granular the permissions will get though. giving model-level access to something like Gmail sounds powerful, but also like a privacy minefield if not done carefully. curious to see how trust and isolation get handled.
they’re supposed to if the deviation is material. that’s what “pre-announcements” are for. but it’s a gray area unless it’s something truly drastic. a 32% QoQ drop probably qualifies, but companies sometimes gamble that the full context will soften the blow on earnings day.
keybase had promise early on but kinda lost the plot. the vouching system was neat in theory but never really caught on outside a small circle. the crypto stuff definitely didn’t help, and once zoom bought them it was basically a ghost town, no roadmap, no real dev activity, just inertia.
feels like identity + trust systems keep coming back around but never quite stick. maybe too hard to balance usability, decentralization, and adoption all at once.