>Maybe this setup is faster compared to the old way of working. But I also think it’s an unfair comparison. Working like this requires a much deeper involvement of domain and product experts. This involvement would mean writing out every feature and bug fix down to the tiniest detail.

The game-changer here with AI in software development is that now the Subject Matter Experts (SMEs) can directly guide AI (Claude Code, Cursor, Codex...etc) to translate the vision into code, review and iterate.

Yes, you are removing the developer from this step of the process, at least to build the MVP version of the service/backend/frontend.

By doing this,the process goes faster, as AI codes faster and the iteration with the SME goes way faster as well since there is no handover; you also lower the "quality attrition" of the process handover (in this case expert to developer), since the expert will explain the function to an AI that also has the deep knowledge in the expert field.

Obviously developers still are needed for the refactoring/hardening/compliance of that vibe-coded solution with corporate architectural/security guidelines, but soon enough those things will be done by AI too.

We are seeing this happening right now at all the big companies who are having a gigantic wave of employees (tech AND business) using Cursor, Claude Code and Codex.

So the skills will need to change and SMEs and developers will probably merge into one person that will have deep domain expertise, some systems and architecture knowledge to work more effectively with AI.

Of course this new reality will bring a lot of challenges. Like the software governance issue that some companies (e.g. Amazon) having problems with the huge proliferation of vibe coded solutions that overlap with each other (probably with different outputs) and create confusion in the business...

But isn’t this just a semantics discussion? Is there a rule for abstraction in CS that says it needs to be deterministic (I really don’t know)?

I believe deterministic abstraction to natural language is impossible to reach by the very ambiguous nature of it, we get misunderstandings when we talk to each other so naturally when talking to a machine it would need to be probabilistic to understand how to translate it to code.

...and I obviously asked Gemini about it and it replied:

"A language optimized exclusively for Large Language Model (LLM) efficiency would prioritize Token Density, Context Window Management, and Architectural Alignment. It would not be binary, as standard LLM architectures (Transformers) process discrete tokens from a predefined vocabulary, not raw bits."

Example of it:

  Feature        Human-Readable (Python/C++)       LLM-Native (Hypothetical)
  --------------------------------------------------------------------------
  Logic          if (x > 10) { return true; }      ¿x10†
  Memory         int\* ptr = malloc(sizeof(int));  §m4
  Tokens Used    ~10-15                            2-3

The usual cycle with startups is to:

- Start being very open, as this brings people developing over the platforms and generates growth

- As long as they are growing, VC money will come to pay for everything. This is the scale up phase

- Then comes the VC exit, IPO or whatever

- Now the new owners don't want user growth, they want margin growth. This is the company phase

- Companies then have monetize their users (why not ads?), close up free, or high-maintenance stuff that do not bring margin

- and report that sweet $$$ growth quarter after quarter

...until a new startup comes in and starts the cycle over again, destroying all the value the old company had.

A mix of Enshittification and Innovators Dilemma theories

But it reminded one of the firsts prompts I tried with ChatGPT back in 2022. I asked him to simulate a text-based adventure (based on the discworld universe) and every command I gave it would behave as an open world text RPG. It was pretty mindblowing

Also for MS it is worth to keep investing little by little,getting concessions from OpenAI and becoming the de facto owner of it.