u/grandimam

There is an emerging problem in tech now that the market is hyper-focused on developer productivity: people are optimising their profiles to suit the market, fuelled by the growing sentiment that coding and full-stack development is a solved problem.

I partly agree. Building basic CRUD apps is largely solved, and that is what a significant portion of developers were doing before Codex and Claude launched. But having worked heavily with major AI tools, it is clearly evident to me that expertise matters more than ever. Your ability to understand a portion of software or a domain deeply is going to take you a long way.

Writing software fast using LLMs is now a common expectation - preferred and appreciated. But to do that well, you need a deep understanding of what you are using. Catering to the LLM is a skill.

I am not saying you should not pivot your career around specific tooling. Do it if you deeply care about it. Otherwise, your moat is in going deeper in one area and relying on LLMs for breadth.

The hard parts are still hard - distributed systems, data modelling, performance under real load, security. AI was never a threat where there was no moat to begin with. If your only moat was working long hours to build the same old stuff, that is gone.

The skill of tomorrow is not prompting. It is knowing what context to load, what output to trust, and how to integrate all of it inside a problem space that is still messy and still yours. No frontier model is going to help you with that. Things are still breaking in production.

Depth takes years to build. But there is one thing each developer already has that is deeply their own: intuition. Intuition for how a problem should be solved. For how it will fail under load. For how a user will actually use the thing versus how the spec says they will. Unless you compound on that, you will always be playing catch up.

There is an emerging problem in tech now that the market is hyper-focused on developer productivity: people are optimising their profiles to suit the market, fuelled by the growing sentiment that coding and full-stack development is a solved problem.

I partly agree. Building basic CRUD apps is largely solved, and that is what a significant portion of developers were doing before Codex and Claude launched. But having worked heavily with major AI tools, it is clearly evident to me that expertise matters more than ever. Your ability to understand a portion of software or a domain deeply is going to take you a long way.

Writing software fast using LLMs is now a common expectation - preferred and appreciated. But to do that well, you need a deep understanding of what you are using. Catering to the LLM is a skill.

I am not saying you should not pivot your career around specific tooling. Do it if you deeply care about it. Otherwise, your moat is in going deeper in one area and relying on LLMs for breadth.

The hard parts are still hard - distributed systems, data modelling, performance under real load, security. AI was never a threat where there was no moat to begin with. If your only moat was working long hours to build the same old stuff, that is gone.

The skill of tomorrow is not prompting. It is knowing what context to load, what output to trust, and how to integrate all of it inside a problem space that is still messy and still yours. No frontier model is going to help you with that. Things are still breaking in production.

Depth takes years to build. But there is one thing each developer already has that is deeply their own: intuition. Intuition for how a problem should be solved. For how it will fail under load. For how a user will actually use the thing versus how the spec says they will. Unless you compound on that, you will always be playing catch up.

There is an emerging problem in tech now that the market is hyper-focused on developer productivity: people are optimising their profiles to suit the market, fuelled by the growing sentiment that coding and full-stack development is a solved problem.

I partly agree. Building basic CRUD apps is largely solved, and that is what a significant portion of developers were doing before Codex and Claude launched. But having worked heavily with major AI tools, it is clearly evident to me that expertise matters more than ever. Your ability to understand a portion of software or a domain deeply is going to take you a long way.

Writing software fast using LLMs is now a common expectation - preferred and appreciated. But to do that well, you need a deep understanding of what you are using. Catering to the LLM is a skill.

I am not saying you should not pivot your career around specific tooling. Do it if you deeply care about it. Otherwise, your moat is in going deeper in one area and relying on LLMs for breadth.

The hard parts are still hard - distributed systems, data modelling, performance under real load, security. AI was never a threat where there was no moat to begin with. If your only moat was working long hours to build the same old stuff, that is gone.

The skill of tomorrow is not prompting. It is knowing what context to load, what output to trust, and how to integrate all of it inside a problem space that is still messy and still yours. No frontier model is going to help you with that. Things are still breaking in production.

Depth takes years to build. But there is one thing each developer already has that is deeply their own: intuition. Intuition for how a problem should be solved. For how it will fail under load. For how a user will actually use the thing versus how the spec says they will. Unless you compound on that, you will always be playing catch up.

There is an emerging problem in tech now that the market is hyper-focused on developer productivity: people are optimising their profiles to suit the market, fuelled by the growing sentiment that coding and full-stack development is a solved problem.

I partly agree. Building basic CRUD apps is largely solved, and that is what a significant portion of developers were doing before Codex and Claude launched. But having worked heavily with major AI tools, it is clearly evident to me that expertise matters more than ever. Your ability to understand a portion of software or a domain deeply is going to take you a long way.

Writing software fast using LLMs is now a common expectation - preferred and appreciated. But to do that well, you need a deep understanding of what you are using. Catering to the LLM is a skill.

I am not saying you should not pivot your career around specific tooling. Do it if you deeply care about it. Otherwise, your moat is in going deeper in one area and relying on LLMs for breadth.

The hard parts are still hard - distributed systems, data modelling, performance under real load, security. AI was never a threat where there was no moat to begin with. If your only moat was working long hours to build the same old stuff, that is gone.

The skill of tomorrow is not prompting. It is knowing what context to load, what output to trust, and how to integrate all of it inside a problem space that is still messy and still yours. No frontier model is going to help you with that. Things are still breaking in production.

Depth takes years to build. But there is one thing each developer already has that is deeply their own: intuition. Intuition for how a problem should be solved. For how it will fail under load. For how a user will actually use the thing versus how the spec says they will. Unless you compound on that, you will always be playing catch up.

There is an emerging problem in tech now that the market is hyper-focused on developer productivity: people are optimising their profiles to suit the market, fuelled by the growing sentiment that coding and full-stack development is a solved problem.

I partly agree. Building basic CRUD apps is largely solved, and that is what a significant portion of developers were doing before Codex and Claude launched. But having worked heavily with major AI tools, it is clearly evident to me that expertise matters more than ever. Your ability to understand a portion of software or a domain deeply is going to take you a long way.

Writing software fast using LLMs is now a common expectation - preferred and appreciated. But to do that well, you need a deep understanding of what you are using. Catering to the LLM is a skill.

I am not saying you should not pivot your career around specific tooling. Do it if you deeply care about it. Otherwise, your moat is in going deeper in one area and relying on LLMs for breadth.

The hard parts are still hard - distributed systems, data modelling, performance under real load, security. AI was never a threat where there was no moat to begin with. If your only moat was working long hours to build the same old stuff, that is gone.

The skill of tomorrow is not prompting. It is knowing what context to load, what output to trust, and how to integrate all of it inside a problem space that is still messy and still yours. No frontier model is going to help you with that. Things are still breaking in production.

Depth takes years to build. But there is one thing each developer already has that is deeply their own: intuition. Intuition for how a problem should be solved. For how it will fail under load. For how a user will actually use the thing versus how the spec says they will. Unless you compound on that, you will always be playing catch up.

There is an emerging problem in tech now that the market is hyper-focused on developer productivity: people are optimising their profiles to suit the market, fuelled by the growing sentiment that coding and full-stack development is a solved problem.

I partly agree. Building basic CRUD apps is largely solved, and that is what a significant portion of developers were doing before Codex and Claude launched. But having worked heavily with major AI tools, it is clearly evident to me that expertise matters more than ever. Your ability to understand a portion of software or a domain deeply is going to take you a long way.

Writing software fast using LLMs is now a common expectation - preferred and appreciated. But to do that well, you need a deep understanding of what you are using. Catering to the LLM is a skill.

I am not saying you should not pivot your career around specific tooling. Do it if you deeply care about it. Otherwise, your moat is in going deeper in one area and relying on LLMs for breadth.

The hard parts are still hard - distributed systems, data modelling, performance under real load, security. AI was never a threat where there was no moat to begin with. If your only moat was working long hours to build the same old stuff, that is gone.

The skill of tomorrow is not prompting. It is knowing what context to load, what output to trust, and how to integrate all of it inside a problem space that is still messy and still yours. No frontier model is going to help you with that. Things are still breaking in production.

Depth takes years to build. But there is one thing each developer already has that is deeply their own: intuition. Intuition for how a problem should be solved. For how it will fail under load. For how a user will actually use the thing versus how the spec says they will. Unless you compound on that, you will always be playing catch up.

Are any of you seeing “2x productivity” expectations emerging in your orgs after adopting LLM coding tools? If so, how is it actually showing up in practice explicit targets, implicit pressure, or just management narrative?

More importantly, how are engineers navigating it? It feels unclear whether this is: a real shift in delivery capacity, or just faster coding being reinterpreted as higher expected output (with review/QA becoming the new bottleneck)

Curious what people are experiencing across startups vs big tech vs more regulated environments.

Are any of you seeing “2x productivity” expectations emerging in your orgs after adopting LLM coding tools? If so, how is it actually showing up in practice explicit targets, implicit pressure, or just management narrative?

More importantly, how are engineers navigating it? It feels unclear whether this is: a real shift in delivery capacity, or just faster coding being reinterpreted as higher expected output (with review/QA becoming the new bottleneck)

Curious what people are experiencing across startups vs big tech vs more regulated environments.

Are any of you seeing “2x productivity” expectations emerging in your orgs after adopting LLM coding tools? If so, how is it actually showing up in practice explicit targets, implicit pressure, or just management narrative?

More importantly, how are engineers navigating it? It feels unclear whether this is: a real shift in delivery capacity, or just faster coding being reinterpreted as higher expected output (with review/QA becoming the new bottleneck)

Curious what people are experiencing across startups vs big tech vs more regulated environments.

I have been trying to evolve our team's development process toward a mix of Test-Driven Development (TDD) and Spec-Driven Development (SDD), and I wanted to get some feedback from this community.

The core idea I am exploring is to treat specs as the primary artifact, and shift code generation to LLM-based agents - while keeping the thinking, design, and reasoning with engineers.

Here is roughly how I am approaching it for each feature within our team:

• I start with a single spec that clearly defines success criteria.
• Engineers (sometimes one, sometimes multiple) scope out the implementation in detail.
• We align as stakeholders on how the feature should be built, often going as far as method signatures, naming, and structure.
• The spec is iterated on until it’s concrete and unambiguous.
• Once finalized, I let LLM agents generate the code from the spec.

Right now, the specs cover frontend, backend, and automation. One thing I have realized is that automation should effectively prove the success criteria. If something can’t be validated through automated tests or pipelines, I push it to manual QA.

Longer term, I am aiming to move as much as possible toward full automation. That means:

• Engineers need visibility into how automation is implemented.
• Manual QA becomes the exception, not the default used only when there’s a strong reason.

Curious to hear from anyone who’s tried something similar -especially around failure modes or what needed to change for this to work in practice.

I have been trying to evolve our team's development process toward a mix of Test-Driven Development (TDD) and Spec-Driven Development (SDD), and I wanted to get some feedback from this community.

The core idea I am exploring is to treat specs as the primary artifact, and shift code generation to LLM-based agents - while keeping the thinking, design, and reasoning with engineers.

Here is roughly how I am approaching it for each feature within our team:

• I start with a single spec that clearly defines success criteria.
• Engineers (sometimes one, sometimes multiple) scope out the implementation in detail.
• We align as stakeholders on how the feature should be built, often going as far as method signatures, naming, and structure.
• The spec is iterated on until it’s concrete and unambiguous.
• Once finalized, I let LLM agents generate the code from the spec.

Right now, the specs cover frontend, backend, and automation. One thing I have realized is that automation should effectively prove the success criteria. If something can’t be validated through automated tests or pipelines, I push it to manual QA.

Longer term, I am aiming to move as much as possible toward full automation. That means:

• Engineers need visibility into how automation is implemented.
• Manual QA becomes the exception, not the default used only when there’s a strong reason.

Curious to hear from anyone who’s tried something similar -especially around failure modes or what needed to change for this to work in practice.

I have been trying to evolve our team's development process toward a mix of Test-Driven Development (TDD) and Spec-Driven Development (SDD), and I wanted to get some feedback from this community.

The core idea I am exploring is to treat specs as the primary artifact, and shift code generation to LLM-based agents - while keeping the thinking, design, and reasoning with engineers.

Here is roughly how I am approaching it for each feature within our team:

• I start with a single spec that clearly defines success criteria.
• Engineers (sometimes one, sometimes multiple) scope out the implementation in detail.
• We align as stakeholders on how the feature should be built, often going as far as method signatures, naming, and structure.
• The spec is iterated on until it’s concrete and unambiguous.
• Once finalized, I let LLM agents generate the code from the spec.

Right now, the specs cover frontend, backend, and automation. One thing I have realized is that automation should effectively prove the success criteria. If something can’t be validated through automated tests or pipelines, I push it to manual QA.

Longer term, I am aiming to move as much as possible toward full automation. That means:

• Engineers need visibility into how automation is implemented.
• Manual QA becomes the exception, not the default used only when there’s a strong reason.

Curious to hear from anyone who’s tried something similar -especially around failure modes or what needed to change for this to work in practice.

I have been trying to evolve our team's development process toward a mix of Test-Driven Development (TDD) and Spec-Driven Development (SDD), and I wanted to get some feedback from this community.

The core idea I am exploring is to treat specs as the primary artifact, and shift code generation to LLM-based agents - while keeping the thinking, design, and reasoning with engineers.

Here is roughly how I am approaching it for each feature within our team:

• I start with a single spec that clearly defines success criteria.
• Engineers (sometimes one, sometimes multiple) scope out the implementation in detail.
• We align as stakeholders on how the feature should be built, often going as far as method signatures, naming, and structure.
• The spec is iterated on until it’s concrete and unambiguous.
• Once finalized, I let LLM agents generate the code from the spec.

Right now, the specs cover frontend, backend, and automation. One thing I have realized is that automation should effectively prove the success criteria. If something can’t be validated through automated tests or pipelines, I push it to manual QA.

Longer term, I am aiming to move as much as possible toward full automation. That means:

• Engineers need visibility into how automation is implemented.
• Manual QA becomes the exception, not the default used only when there’s a strong reason.

Curious to hear from anyone who’s tried something similar -especially around failure modes or what needed to change for this to work in practice.