#blogPostAsWebApp: https://voku.github.io/LinkedOut/
Introduction: The Carpenter and the Nail Gun
Imagine two carpenters.
One measures, plans, understands load distribution, humidity, long-term material behavior.
The other is very, very fast with a nail gun.
Now someone invents a nail gun that shoots 10x faster and never gets tired.
Who is in danger?
Not the carpenter.
The nail gun operator.
That’s exactly where large language models have landed in our industry.
And yes — this absolutely affects PHP, remote jobs, and top salaries.
Let’s remove the mysticism and talk about structure, economics, and responsibility.
Background: We’ve Seen This Movie Before
The panic isn’t loud. It’s subtle.
- “AI Engineer”
- “LLM Architect”
- “AI-First Developer”
Yesterday: TYPO3 integrator.
Today: AI systems builder.
But we’ve seen this dynamic before:
- When frameworks replaced manual routing.
- When ORMs replaced handwritten SQL.
- When CI/CD replaced FTP deployments.
- When static analysis replaced “it works on my machine.”
Every time, the market compressed mechanical work and rewarded structural thinking.
If you’ve worked long enough in legacy systems, you know this already: tools don’t save you — structure does.
AI is just another compression tool.
But this one is extremely good at pattern instantiation.
1. Remove the Mysticism: What LLMs Actually Are
LLMs are:
- Probabilistic language models
- Pattern reproduction engines
- Context compressors
- Next-token predictors
They are not:
- Architects
- System designers
- Domain experts
- Responsible entities
They don’t understand your business invariants.
They don’t reason about financial risk.
They don’t carry production liability.
They produce plausibility.
And plausibility is often good enough — for boilerplate.
2. The Uncomfortable Truth: They Are Good Enough
LLMs are extremely good at:
- CRUD scaffolding
- DTO generation
- Test templates
- API wrappers
- Refactoring noise
- Documentation synthesis
And let’s be brutally honest:
A large percentage of web development is pattern repetition.
Not distributed consensus.
Not formal modeling.
Not deep domain design.
Pattern instantiation.
If your value was:
- Assembling plugins
- Copy-adapting controllers
- Wiring framework defaults
- Repeating known structures
Then yes — LLMs are competitive with you.
This is not an insult.
It’s economics.
Compression removes redundancy.
And redundancy is where mediocre value hides.
3. The Real Divide: Medium Developer vs. Professional With AI
This is not:
AI vs. No AI
This is:
Medium Developer vs. Professional With AI
The Medium Developer
- Uses LLM like Google.
- Requests full solutions.
- Iterates blindly.
- Accepts verbose output.
- Ships quickly.
- Accumulates entropy.
They generate more code.
And if you’ve read How to write readable code? you already know: more code ≠ better code.
The Professional
- Defines constraints first.
- Encodes invariants via types.
- Uses static analysis aggressively.
- Injects domain logic manually.
- Validates output.
- Deletes 70% of generated noise.
They multiply thinking instead of outsourcing it.
They use principles like those defined in the Codelight Manifesto :
- Clarity
- Optimization (after correctness)
- Error handling
- Generics
- Human-centric design
The professional treats AI like a deterministic macro engine.
Not like a brain.
4. The Token Dilemma: We’re Paying for Lines of Code Again
Remember the 90s mistake?
Paying developers by lines of code.
Now look at token billing models.
We are literally paying for output length.
What does the model optimize for?
- More explanation
- More scaffolding
- More verbosity
- More plausible filler
It’s the ultimate junior developer incentive structure.
As someone said recently:
My productivity as a senior developer no longer comes from writing faster.
It comes from deleting faster.
This aligns perfectly with white space discipline from Do Not Fear The White Space in your Code :
Clarity is subtraction.
AI generates quantity.
Experts generate quality by omission.
5. Where Top PHP Salaries Actually Live
Let’s answer the core question.
Can you still earn top PHP salaries, 100% remote, without AI?
Yes.
But only if your value is above the compression layer.
That layer includes:
- Architectural trade-offs
- Long-term maintainability
- Static analysis integration
- Refactoring strategy
- Security guarantees
- Performance bottleneck diagnosis
- Domain modeling
- Responsibility under production pressure
This is exactly the mindset described in What have I learned so far in my job? :
- No panic.
- Read official documentation.
- Think before acting.
- Solve root causes.
- Learn continuously.
AI does not remove the need for that.
It increases the need.
6. Implementation: Professional AI Usage in Modern PHP
Here’s the difference in practice.
Step 1 – Encode Constraints First
Use modern PHP features (see PHP 8.x guide ):
declare(strict_types=1);
readonly class Money
{
public function __construct(
/** @var numeric-string $amount */
public string $amount,
public string $currency
) {
if (!is_numeric($amount)) {
throw new InvalidArgumentException('Amount must be numeric.');
}
}
}
Step 2 – Add Static Guarantees
Leverage advanced PHPDoc generics and shapes (see coding standards ):
/**
* @param non-empty-list<Money> $items
*/
function calculateTotal(array $items): Money
{
// AI can scaffold this.
// You verify invariants.
}
Step 3 – Let AI Scaffold, Not Decide
Ask AI to:
- Generate repetitive repository boilerplate
- Create test skeletons
- Draft migration scripts
But you:
- Review types
- Validate edge cases
- Remove unnecessary abstractions
- Reduce surface area
AI becomes a deterministic macro tool.
Not a system designer.
7. Common Pitfalls in the AI Era
❌ Blind Acceptance
Shipping plausible but unverified code.
❌ Over-Abstraction
Generating factories for trivial objects because the model “likes patterns.”
❌ Entropy Explosion
More code → more maintenance → more hidden bugs.
❌ Replacing Thinking
Outsourcing domain decisions to a statistical engine.
8. Best Practices for Surviving the Compression
- Strengthen type systems.
- Use PHPStan aggressively.
- Automate refactoring.
- Enforce code style automatically.
- Reduce public surface area.
- Prefer deletion over addition.
- Move up the abstraction ladder.
Think like a systems engineer, not a syntax operator.
Conclusion: The Market Is Compressing — Not Dying
LLMs are not architects.
They are pattern engines.
But in a world where much work is pattern instantiation, pattern engines are disruptive.
You can absolutely earn top PHP salaries, 100% remote.
But not if your value was:
typing code faster than others.
You must operate where:
- Patterns stop
- Trade-offs begin
- Responsibility matters
Everything below that layer is compressing.
Compression does not care about feelings.
It cares about economics.
Summary
- AI is a compression engine for repetitive code.
- Mechanical developers are at risk.
- Structural thinkers are amplified.
- Token-based billing incentivizes verbosity.
- Experts win by deleting, not generating.
- Modern PHP + strict typing + static analysis are your leverage.
Call to Action
Audit your own work.
- Are you adding value above the pattern layer?
- Or are you a very fast nail gun operator?
Implement code quality gates: static analysis, test coverage, ...
Automate the boring parts.
Move upward in abstraction.
Let the LLM write code generators that write deterministic code.