DEV Community: Tonmoy Chandra Mudi

10% of Uber’s Workforce Is Gone

Tonmoy Chandra Mudi — Wed, 02 Sep 2026 14:45:11 +0000

Uber is reportedly cutting around 3,300 jobs, roughly 10% of its global workforce, in its largest round of layoffs since the COVID-19 pandemic.

But there’s something more interesting here than the headline.

This isn't simply an "AI replaced developers" story.

According to Reuters, Uber CEO Dara Khosrowshahi described the restructuring as an effort to create a leaner organization, reduce management layers, speed up decision-making, and redirect resources toward growth and innovation.

And there are several important lessons here for software engineers. 👇

🚨 What is happening at Uber?

Uber has around 34,000 employees, and the company plans to eliminate approximately 3,300 positions.

The restructuring includes:

📉 About 10% workforce reduction
🏢 20% reduction in employees seven or more reporting layers below the CEO
🔄 Combining some teams
👥 Nearly halving teams with only one or two direct reports
🏠 Fully remote positions limited to roughly 1% of the workforce
🏢 Continuing the three-day office policy
🤖 Increasing investment in autonomous vehicles and robotaxis

Uber says the goal is to reduce organizational complexity and make decisions faster.

But there is another major factor behind the company's strategy:

🤖 Robotaxis are changing Uber's business

Uber's traditional model depends heavily on human drivers.

But autonomous vehicles are changing that equation.

Companies such as Waymo and Tesla are pushing aggressively into autonomous transportation.

Uber therefore wants to position itself as the marketplace connecting passengers with autonomous vehicles rather than becoming irrelevant as transportation becomes increasingly automated.

The company plans to invest more than $10 billion in robotaxis in the coming years.

That creates a very different engineering environment.

The technology stack isn't just:

Mobile app → Backend → Database

It increasingly involves:

AI/ML → Autonomous systems → Real-time infrastructure → Mapping → Computer vision → Distributed systems → Cloud → Robotics

And that leads to the bigger lesson.

💡 AI isn't necessarily the direct reason for every layoff

This is an important distinction.

A lot of tech layoffs in 2026 are being associated with AI.

But Uber's CEO did not directly blame AI for these layoffs.

Instead, Uber is restructuring around:

organizational efficiency
autonomous vehicles
faster decision-making
reduced management overhead
changing business economics
technological transformation

AI may still contribute to productivity and changing workforce requirements, but the situation is more complicated than:

"AI → replaces developers → layoffs."

Business strategy matters enormously.

👨‍💻 What does this mean for software engineers?

This is where I think developers should pay attention.

The safest career strategy isn't:

"Learn one programming language and get really good at writing code."

The industry is increasingly rewarding engineers who can solve problems using technology.

For example:

A developer who only knows how to write CRUD APIs is competing in a much larger pool.

But an engineer who understands:

Python + Backend + Databases + Cloud + Distributed Systems + AI/ML

can potentially contribute to much more complex systems.

The same applies to frontend, DevOps, cybersecurity, data engineering, etc.

🧠 Don't compete with AI at what AI is good at

AI is becoming extremely good at:

boilerplate code
simple CRUD applications
basic unit tests
documentation
code translation
simple debugging
generating repetitive components

So trying to compete with AI by becoming the world's fastest boilerplate writer isn't a great long-term strategy.

Instead, develop skills AI doesn't easily replace:

System design

Understand how large systems actually work.

Learn:

Distributed systems
Caching
Message queues
Load balancing
Database architecture
Scalability
Reliability
Fault tolerance

Strong computer science fundamentals

Don't skip:

Data Structures & Algorithms
Operating Systems
Computer Networks
Databases
Concurrency
Algorithms

These concepts remain useful regardless of which programming language or framework becomes popular.

Domain knowledge

Uber isn't just a software company.

It operates in:

🚗 Transportation
🍔 Food delivery
💳 Payments
🗺️ Maps
🤖 Autonomous vehicles
📊 Logistics
☁️ Large-scale infrastructure

Engineers who understand the business domain can make better technical decisions.

AI literacy

You don't necessarily need to become an AI researcher.

But modern engineers should understand:

LLMs
RAG
Embeddings
Vector databases
AI agents
Model APIs
Evaluation
AI-assisted development
ML fundamentals

The goal isn't to blindly use AI.

The goal is to know when and how to use it effectively.

🏢 Another interesting lesson: organizational complexity

One detail from Uber's restructuring particularly caught my attention.

Uber plans to reduce employees who are seven or more reporting layers below the CEO by 20%.

That's not really a programming problem.

It's an organizational architecture problem.

As companies grow, they naturally accumulate:

Teams → managers → managers of managers → coordination → meetings → approvals → bureaucracy

Eventually, too much engineering time can be spent coordinating work rather than building products.

A company can have thousands of talented engineers and still become slow.

So engineering organizations also need something similar to good software architecture:

Less unnecessary complexity.

🌎 What should students and junior developers do?

If you're currently learning software engineering, don't panic when you see another layoff headline.

Instead, use it as a signal.

I'd focus on building this stack:

Computer Science Fundamentals
↓
Programming
↓
Data Structures & Algorithms
↓
Backend Development
↓
Databases
↓
Linux + Git
↓
Cloud + Distributed Systems
↓
AI/ML Fundamentals
↓
Real-world Projects
↓
System Design

And most importantly:

Build things that solve actual problems.

A portfolio containing:

"Todo App"

is fine for learning.

But a project involving:

Authentication + PostgreSQL + REST API + caching + background jobs + Docker + cloud deployment + monitoring + AI integration

demonstrates a much deeper engineering skill set.

🔥 The bigger picture

Uber's layoffs aren't proof that software engineering is dying.

They're evidence that the software industry is changing.

Companies are continuously asking:

"What work actually creates value?"

And engineers should ask themselves the same question.

The future probably won't belong exclusively to:

"AI engineers."

Nor will it belong exclusively to:

"traditional software developers."

The strongest engineers will increasingly be people who can combine:

Software Engineering + Computer Science + AI + Systems Thinking + Domain Knowledge

That's the direction I'm personally watching very closely.

What do you think?

Are layoffs like Uber's primarily about:

A) AI and automation
B) Organizational inefficiency
C) Changing business models
D) Economic pressure
E) A combination of all four?

I'd love to hear what other developers think. 👇

dev #softwareengineering #programming #ai #machinelearning #careers #tech #developers #uber #robotaxi #artificialintelligence #coding

Why Some Companies Are Pulling Back on AI Coding

Tonmoy Chandra Mudi — Tue, 18 Aug 2026 07:09:54 +0000

AI coding assistants have changed software development incredibly fast.

Tasks that used to take hours — writing boilerplate, generating tests, explaining APIs, creating documentation, refactoring code, or building prototypes — can now take minutes.

Tools like GitHub Copilot and modern coding agents have become part of many developers' daily workflows.

So here's an interesting question:

If AI coding makes developers more productive, why are some companies restricting or even banning it?

The answer isn't that AI coding doesn't work.

The problem is that generating code and engineering software are two very different things.

Code Generation ≠ Software Engineering

Large language models have become surprisingly good at generating code.

Give an AI a well-defined problem and it can often produce a working implementation in seconds.

For example:

def delete_customer(customer_id):
db.execute(
"DELETE FROM customers WHERE id = ?",
customer_id
)

Looks reasonable.

But production software rarely ends with a single database operation.

Deleting a customer might also require:

Revoking API keys
Cancelling active subscriptions
Removing IAM permissions
Invalidating cached sessions
Archiving invoices for legal compliance
Publishing a CustomerDeleted event
Updating CRM systems
Notifying downstream services
Updating analytics pipelines
Handling audit logs
Maintaining data-retention requirements

The code itself might be correct.

The system behavior might still be wrong.

And that's the fundamental problem.

AI is becoming very good at writing code. Software engineering requires understanding why that code needs to exist in the first place.

The Hidden Complexity of Real Software

A real enterprise application isn't just a collection of functions.

It may contain:

Application
│
├── Frontend
├── Backend
├── Database
├── Authentication
├── Payment systems
├── Message queues
├── Caching
├── Microservices
├── Cloud infrastructure
├── Monitoring
├── Logging
├── Security policies
├── Third-party APIs
└── Compliance requirements

Changing one component can affect many others.

A developer might know that:

"This function is called by these three services."

An AI model may only see:

"Here is the code currently provided in the context."

That difference matters.

Software engineering requires system-level state and context, not just local code understanding.

Why Are Companies Restricting AI Coding?

There are several major reasons.

Correctness

LLMs generate outputs probabilistically.

That means an AI can produce code that looks completely reasonable while containing a subtle bug.

For example:

Race conditions
Incorrect error handling
Off-by-one errors
Security vulnerabilities
Incorrect API assumptions
Concurrency problems
Performance regressions
Incorrect database transactions

The dangerous part isn't code that obviously doesn't work.

It's code that looks like it works.

Maintainability

Imagine five developers implementing the same architectural problem.

A good engineering team usually establishes a consistent abstraction.

AI can instead produce five different solutions.

For example:

Developer A

user = repository.get(id)

Developer B

user = User.objects.get(pk=id)

Developer C

user = db.query(User).filter(User.id == id).first()

Developer D

user = get_user_from_cache_or_db(id)

Each solution might be valid individually.

But across a large codebase, inconsistent patterns increase:

Cognitive load
Technical debt
Maintenance costs
Onboarding difficulty
Refactoring complexity

AI can therefore increase code velocity while simultaneously increasing architectural entropy.

Security

Security is another major concern.

Companies have to consider questions like:

What happens to proprietary source code?

If developers send internal implementation details to an external AI service, organizations need to understand exactly how that data is handled.

There are also risks involving:

Prompt injection
Secrets and credentials
Vulnerable dependencies
Insecure code suggestions
Supply-chain attacks
Data leakage
Malicious instructions hidden in repositories

For a personal project, the risk might be relatively small.

For a bank, hospital, government system, or defense contractor, the consequences can be enormous.

Accountability

This might be the most interesting problem.

Suppose an AI-generated change causes a production outage.

Who is responsible?

The AI?

The developer who accepted the suggestion?

The reviewer?

The engineering manager?

The company?

Ultimately, organizations still need a human being who can answer:

Why was this architectural decision made?

An AI model doesn't have ownership of the system.

It doesn't have organizational responsibility.

And it doesn't experience the consequences of a production failure.

That's why human accountability remains essential.

The Trust Gap

AI coding has improved dramatically, but several gaps remain.

Long-term reasoning

AI can reason about a task in its current context.

Maintaining architectural consistency across years of development is much harder.

Verification

Generated code can look correct while violating hidden requirements.

Tests don't necessarily catch every problem.

Decomposition

Large engineering projects can contain hundreds or thousands of interconnected tasks.

Breaking those tasks down correctly and coordinating their dependencies is significantly harder than implementing individual functions.

Persistent memory

Software projects accumulate decisions:

Why did we choose PostgreSQL?

Why isn't this service using Redis?

Why is this API version still supported?

Why can't this table be modified directly?

Why does this seemingly unnecessary validation exist?

Often, the answers aren't obvious from the code.

They're hidden in:

Architecture documents
Git history
Incident reports
Slack conversations
Tickets
Team knowledge
Business requirements

That's the context an autonomous engineering system needs to understand.

But AI Coding Isn't Going Away

Despite all of these problems, I don't think companies are going to abandon AI coding.

The productivity benefits are simply too significant.

AI is already extremely useful for tasks such as:

Boilerplate generation
Unit tests
Documentation
API integration
Code explanations
Migration work
Internal tools
Prototyping
Refactoring
Code review preparation
Debugging assistance

The important distinction is where we place the AI in the engineering process.

The Future Isn't "AI vs Developers"

The more realistic future looks something like this:

            ┌───────────────┐
            │   Developer   │
            └───────┬───────┘
                    │
                    ▼
          ┌──────────────────┐
          │   AI Coding      │
          │     Agents       │
          └────────┬─────────┘
                   │
      ┌────────────┼────────────┐
      ▼            ▼            ▼
   Testing      Security     Verification
      │            │            │
      └────────────┼────────────┘
                   ▼
             Human Review
                   │
                   ▼
               Production
                   │
                   ▼
            Runtime Monitoring

AI generates and modifies code.

Other systems verify it.

Humans make the final engineering decisions.

That is much more realistic than simply giving an AI unrestricted access to an entire production environment.

RAG Helps, But It Isn't Magic

One important technology in this area is Retrieval-Augmented Generation (RAG).

Instead of asking an AI to rely entirely on its training knowledge, we can provide it with relevant information from the actual project.

For example:

Developer asks:
"How should I implement customer deletion?"

         ↓

   Retrieval System

         ↓

Architecture docs
Database schema
API documentation
Business rules
Git history
Internal conventions

Context-aware implementation

This can significantly reduce hallucinations because the model is working with current project information.

But RAG doesn't magically make an AI an experienced software architect.

It gives the model better information.

The model still needs to reason correctly about that information.

The Next Generation of AI Coding

I think the most interesting development won't be a single gigantic model.

It will be the combination of multiple systems:

Reasoning models

For planning and architectural decisions.

Persistent memory

For remembering project history and engineering decisions.

RAG

For retrieving current project knowledge.

Automated testing

For validating generated changes.

Static analysis

For detecting potential bugs and security problems.

Formal verification

For mathematically proving certain properties where applicable.

Runtime observability

For detecting problems after deployment.

Specialized agents

Different agents handling security, testing, infrastructure, databases, documentation, and other domains.

Together, these systems could form something much closer to an AI engineering platform.

So Should Developers Stop Using AI?

Absolutely not.

But developers should change how they use it.

Don't think:

"AI wrote it, so it's probably correct."

Think:

"AI proposed an implementation. Now I need to verify that implementation against the system."

Use AI for acceleration, not blind delegation.

A good workflow might look like:

Understand the requirement
↓
Design the solution
↓
Ask AI for implementation
↓
Review the generated code
↓
Run tests
↓
Run static/security analysis
↓
Check architecture
↓
Review edge cases
↓
Deploy
↓
Monitor

The developer remains responsible for understanding the system.

The Real Skill of the Future

As AI becomes better at writing code, simply knowing how to type code will become less differentiated.

The valuable skills will increasingly be:

System design
Debugging
Architecture
Database design
Distributed systems
Security
Testing
Performance engineering
Understanding business requirements
Reviewing AI-generated code
Knowing when not to trust AI

In other words:

The better AI becomes at coding, the more important engineering judgment becomes.

That's the paradox.

AI may reduce the amount of code developers write while increasing the importance of understanding the code they ship.

Final Thought

The companies restricting AI coding aren't necessarily anti-AI.

They may actually be pro-AI but anti-unverified-AI.

The productivity gains are real.

The risks are real too.

The future probably won't be:

Humans → replaced by AI

It will be closer to:

Humans
+
AI agents
+
Testing
+
Security
+
Verification
+
Observability
=
AI-assisted software engineering

AI can generate code remarkably well.

But production software requires something more difficult:

trust.

And until AI systems can consistently maintain context, understand architecture, verify their decisions, and take responsibility for long-term system behavior, developers will remain an essential part of the loop.

The question isn't whether AI will write more of our code.

It almost certainly will.

The real question is:

How much engineering responsibility are we willing to give it? 🚀

What do you think? Would you trust an AI agent to own a production codebase, or should humans always remain in the loop?

Meta vs. 30 States: Could This Lawsuit Change Social Media Forever?

Tonmoy Chandra Mudi — Mon, 17 Aug 2026 10:15:36 +0000

A jury trial involving 30 U.S. states is set to examine allegations that Meta knowingly designed Instagram and Facebook in ways that could harm young users.

And this isn't simply about paying a fine.

If the states win, Meta could be forced to fundamentally change how its platforms work for teenagers across the United States.

💥 What Are the States Asking For?

The lawsuit alleges that Meta violated federal and state laws related to children's privacy and safety.

The states are seeking potentially more than $1 trillion in damages and are also demanding major product changes.

Among the proposed changes:

👨‍👩‍👧 Parental verification for teenage accounts
🧠 Changes to recommendation algorithms designed to maximize engagement
❤️ Removal of "like" counts for young users
🎥 Ending autoplay for video content
📜 Limiting infinite scrolling
🖼️ Removing certain appearance-altering image filters
🔔 Restricting notifications designed to bring young users back
👤 Preventing teenagers from creating multiple accounts
⏳ Eliminating disappearing content such as Instagram Stories
🚫 Restrictions around sending or receiving explicit content

These aren't minor UI changes.

They target some of the core engagement mechanisms behind modern social media.

🧠 The Real Question: Engagement vs. Well-Being

The case raises an important question for technology companies:

How far should an algorithm go to maximize user engagement?

Social platforms are heavily optimized around metrics such as:

Time spent
Daily active users
Retention
Likes
Comments
Shares
Notifications
Recommendation accuracy

From a product-engineering perspective, these metrics make sense.

More engagement can mean more advertising opportunities and stronger network effects.

But the legal argument from the states is essentially that optimizing these systems without adequately considering their effects on children creates a different kind of responsibility.

And that's where things become interesting.

❤️ The Problem With "Likes"

One of the most controversial features is also one of the simplest:

The Like button.

Likes provide users with an immediate social signal.

For adults, that might simply mean:

"People enjoyed my post."

For teenagers, however, that feedback can become connected to identity, popularity and self-worth.

The states have pointed to Meta's own internal research, which reportedly found that Instagram's social-comparison mechanisms could be associated with:

Increased loneliness
Worse body image
Negative mood
Social comparison

That creates an uncomfortable situation for Meta.

The same mechanisms that make a platform engaging can potentially contribute to negative outcomes for vulnerable users.

⚖️ Meta Has Already Lost Ground

This isn't happening in isolation.

A recent New Mexico ruling ordered Meta to pay $942 million and required changes to how Instagram and Facebook operate for users under 18.

The ruling included measures such as:

Removing like counts for users under 18
Restricting certain types of messaging
Limiting push notifications during specific hours

The judge also described Meta as a "public nuisance", comparing the company's alleged societal impact to other forms of widespread environmental harm.

Meta has said it disagrees with the allegations and plans to appeal.

The upcoming multi-state case could have much broader consequences.

🌎 Why This Case Matters So Much

The 30 states involved represent nearly two-thirds of the U.S. population.

That changes the scale of the problem.

If Meta were required to implement significant product changes across those states, maintaining completely different versions of Instagram and Facebook could become extremely complicated.

The practical solution might be to implement many of those changes across the entire U.S. market.

And that could influence the global direction of social media product design.

👨‍💻 The Engineering Perspective

This case is bigger than Meta.

It's a warning for anyone building products driven by algorithms.

Imagine you're designing a recommendation system.

Your objective function might look something like:

maximize:

user_engagement

retention
session_length
interactions

But what happens when the system also needs to optimize for:

user_wellbeing

privacy
safety
age appropriateness

The engineering problem changes completely.

Instead of asking:

"How do we keep users engaged?"

You may need to ask:

"How do we create value without exploiting predictable weaknesses in human behavior?"

That is a much harder problem.

🤖 The AI Connection

This becomes even more important as AI increasingly controls what people see.

Recommendation systems are becoming more personalized.

Generative AI can create more engaging content.

Algorithms can predict what a user is likely to watch, click, like or share.

The more powerful these systems become, the more important responsible optimization becomes.

A future AI system shouldn't necessarily be judged only by:

Accuracy
Latency
Revenue
Engagement

We may increasingly need metrics such as:

Safety
Fairness
Privacy
Well-being
Long-term user value

That's an engineering challenge—not just a legal one.

🔥 What Happens If Meta Loses?

A major loss could force Meta to rethink fundamental parts of Instagram and Facebook.

And potentially, other social platforms could face similar scrutiny.

That could eventually change the standard design patterns of social media:

Infinite scroll → limited consumption

Likes → private feedback

Autoplay → intentional viewing

Engagement optimization → well-being optimization

Personalization → age-aware personalization

The question isn't whether social media will change.

The bigger question is:

Who gets to decide what the next version of social media looks like—the engineers, the companies, the users, or the courts?

Final Thought

Technology companies have spent more than a decade becoming exceptionally good at capturing attention.

The next decade may require them to become equally good at knowing when not to capture it.

For software engineers and AI engineers, that's an important lesson:

The objective function you choose doesn't just determine what your system optimizes. It determines what your system becomes.

And sometimes, the most important engineering decision isn't how to optimize.

It's what you're optimizing for. 🚀

What do you think?

Should governments have the authority to force social media companies to redesign engagement features for teenagers?

Or should these decisions remain primarily with technology companies and parents?

technology #ai #softwareengineering #webdevelopment #privacy #socialmedia #ethics #machinelearning #meta #programming

AI Is Making Chips More Expensive

Tonmoy Chandra Mudi — Sat, 15 Aug 2026 05:50:52 +0000

When we talk about the AI boom, we usually talk about:

ChatGPT
Claude
Gemini
AI agents
GPUs
LLMs

But underneath all of those technologies is something much more fundamental:

Semiconductors.

And a recent report about China's largest chip foundry, SMIC, shows just how strongly AI demand is reaching into the semiconductor supply chain.

SMIC says AI-related demand remains strong enough that it has raised prices for some of its most sought-after manufacturing capacity.

That's a big signal.

Because AI growth isn't happening only at the software layer.

It's creating enormous demand for physical computing infrastructure.

🏭 First: What Does SMIC Actually Do?

SMIC stands for Semiconductor Manufacturing International Corporation.

Think of a chip company as having several layers.

A simplified version looks like this:

Chip Design
↓
Chip Architecture
↓
Manufacturing
↓
Packaging
↓
Testing
↓
Computer / Server

Companies can design chips without actually manufacturing them.

A foundry manufactures chips designed by other companies.

SMIC is primarily a semiconductor foundry.

Its customers provide chip designs, and SMIC manufactures those designs on semiconductor wafers.

🧠 Why Does AI Need So Many Chips?

Modern AI models require enormous amounts of computation.

Training a large model might involve:

Massive Dataset
↓
Neural Network
↓
Millions/Billions of Parameters
↓
Repeated Computation
↓
Thousands of Accelerators
↓
Huge Energy Consumption

And training isn't the only cost.

Once a model is deployed, millions of users may interact with it.

Every request requires inference.

For example:

User
↓
AI Application
↓
API
↓
Model Server
↓
GPU / AI Accelerator
↓
Inference
↓
Response

Multiply that by millions of users and billions of requests.

The hardware requirements become enormous.

📈 SMIC's Numbers Tell an Interesting Story

According to the Reuters report, SMIC generated more than:

$3 billion in quarterly revenue

for the first time.

Its second-quarter performance was helped by strong AI-related demand.

Some other important numbers:

Metric Result
Q2 Revenue >$3B
Wafer shipments +14% QoQ
Average wafer selling price +5.7%
Monthly capacity 1.1M 8-inch-equivalent wafers
Capacity utilization 93.7%
Q2 shareholder profit $479.2M
H1 capital spending $3.4B
Expected 2026 amortization ~$5B

These numbers show something important:

Demand is strong, but semiconductor manufacturing is extremely capital-intensive.

💰 Why Are Chip Prices Going Up?

The simplest explanation is:

High AI Demand
↓
More Chip Orders
↓
Limited Manufacturing Capacity
↓
Higher Utilization
↓
Tighter Supply
↓
Higher Prices

SMIC's average selling price increased by 5.7% while wafer shipments increased by 14%.

And SMIC said it raised prices for its most sought-after capacity after negotiating with customers.

That's basic supply and demand.

But in semiconductors, increasing supply isn't as simple as:

“Let's build another factory.”

A semiconductor fabrication plant can require billions of dollars and years of planning, construction, equipment installation and qualification.

🔬 What Does “7nm” Mean?

This is another important concept for anyone interested in AI hardware.

SMIC is reported to be the only Chinese foundry currently capable of mass-producing logic chips such as CPUs and GPUs using a 7-nanometre process.

But what does 7nm mean?

Very roughly, it's a label associated with a particular semiconductor manufacturing technology generation.

Smaller process technologies generally aim to provide:

More transistors
Better performance
Improved power efficiency
Greater computational density

A simplified evolution might look like:

Older Process
↓
Larger Transistors
↓
Fewer Transistors / Area
↓
Newer Process
↓
Smaller Features
↓
More Computational Density

Modern AI accelerators depend heavily on advanced semiconductor processes.

🤖 AI Is More Than GPUs

One detail from the SMIC report is particularly interesting.

SMIC said much of the increase in shipments was driven by AI-related demand for chips other than CPUs and GPUs, particularly from Chinese customers.

That's important.

When people hear “AI hardware,” they usually think:

GPU

But an AI infrastructure stack can contain many different kinds of chips.

For example:

         AI Data Center
              │
   ┌──────────┼──────────┐
   ↓          ↓          ↓
 CPU        GPU       Networking
   │          │          │
   └──────────┼──────────┘
              ↓
          Storage
              ↓
         Controllers
              ↓
        Power Systems

AI demand can therefore affect an entire semiconductor ecosystem.

🌐 The AI Supply Chain Is Huge

A modern AI system isn't simply:

GPU + Model

It's more like:

Semiconductor Manufacturing
↓
AI Chips
↓
Servers
↓
Networking
↓
Data Centers
↓
Cloud Platforms
↓
AI Models
↓
Developer APIs
↓
AI Applications
↓
Users

A bottleneck at almost any layer can affect the layers above it.

This is why semiconductor manufacturing is becoming strategically important to the AI industry.

⚡ Why 93.7% Utilization Matters

SMIC reported capacity utilization of approximately:

93.7%

Capacity utilization tells us how much of the available manufacturing capacity is actually being used.

Imagine a factory can theoretically produce:

100 units

but is currently producing:

50 units

Its utilization is:

50 / 100 = 50%

If it produces:

94 / 100

utilization becomes:

94%

A utilization rate around 94% indicates the factory is operating at a very high level.

That's good for revenue.

But it also means there isn't an enormous amount of unused capacity available if demand suddenly increases.

🏗️ The Hidden Cost of AI: CapEx

There's another number developers should pay attention to:

Capital expenditure

SMIC spent approximately $3.4 billion during the first half of the year.

Why so much?

Because semiconductor manufacturing requires expensive infrastructure.

Think:

Fab
↓
Lithography
↓
Deposition
↓
Etching
↓
Ion implantation
↓
Metrology
↓
Packaging
↓
Testing

The equipment involved can be extremely expensive.

This is why semiconductor companies aren't like typical software startups.

A software company might scale by adding:

Servers + Engineers

A semiconductor manufacturer needs:

Factories
+
Specialized equipment
+
Clean rooms
+
Engineers
+
Materials
+
Energy
+
Years of investment
💡 The Interesting Business Lesson

This creates a fascinating economic relationship.

AI companies want:

More compute.

Chip designers want:

More manufacturing capacity.

Foundries want:

More equipment and factories.

Cloud providers want:

More data centers.

And everyone is trying to scale simultaneously.

So the AI boom creates a chain reaction:

AI adoption
↓
More model usage
↓
More compute
↓
More chips
↓
More semiconductor capacity
↓
More factories
↓
More capital investment
🇨🇳 Why SMIC Matters Beyond One Company

There is also a broader strategic dimension.

SMIC is China's largest chip foundry.

The Reuters report says approximately 90% of SMIC's second-quarter revenue came from China, while the United States contributed around 8%.

That tells us how strongly its business is tied to the domestic Chinese technology ecosystem.

And as AI becomes increasingly important to:

Cloud computing
Robotics
Autonomous systems
Defense
Software
Data centers
Consumer electronics

semiconductor manufacturing becomes a strategic capability.

🔥 AI Infrastructure Is Becoming a Competitive Advantage

For years, software developers could think mostly about:

Code
+
Servers

AI changes the equation.

Now the competitive stack increasingly looks like:

Algorithms
↓
Models
↓
Inference
↓
Accelerators
↓
Semiconductors
↓
Manufacturing
↓
Energy

A company can have an incredible AI model.

But if it doesn't have enough compute to serve that model efficiently, scaling becomes difficult.

This is why hardware availability can directly influence software and AI companies.

👨‍💻 What Does This Mean for Developers?

You might be wondering:

“I'm learning Python and AI engineering. Why should I care about semiconductor manufacturing?”

Because understanding the infrastructure beneath AI makes you a better engineer.

You don't necessarily need to become a chip designer.

But you should understand concepts like:

AI Compute
CPU
GPU
TPU
NPU
AI accelerators
Systems
Memory
Networking
Storage
Distributed computing
AI Infrastructure
Model serving
Batching
Quantization
Parallelism
Inference optimization
GPU utilization
Cloud
Containers
Kubernetes
Data centers
Load balancing
Observability

These concepts help you understand what actually happens when your Python code calls an AI model.

🧠 The Developer Perspective

Imagine you build an AI application.

Your code might look incredibly simple:

response = client.generate(
model="some-large-model",
prompt=user_prompt
)

But underneath that one line could be:

Your Python Application
↓
API Gateway
↓
Load Balancer
↓
Inference Server
↓
Model Runtime
↓
GPU Cluster
↓
Networking
↓
Data Center
↓
Semiconductor Hardware

That's the hidden infrastructure behind modern AI.

And understanding that stack is becoming increasingly valuable.

🚀 The Bigger Picture

The SMIC story shows that the AI revolution isn't happening only inside research labs.

It's happening inside:

Factories.

It's happening inside:

Data centers.

It's happening inside:

Cloud platforms.

It's happening inside:

Chip-design teams.

And of course, it's happening inside:

Software applications.

The AI industry is effectively building a new computing infrastructure layer.

🔮 What's Next?

If AI demand continues growing, we'll likely see increasing pressure across the entire compute ecosystem:

More AI applications
↓
More inference
↓
More accelerators
↓
More semiconductor demand
↓
More manufacturing investment
↓
More capacity
↓
Lower bottlenecks

But achieving that isn't easy.

Factories take years.

Equipment is expensive.

Advanced manufacturing is technically difficult.

Energy requirements are significant.

And geopolitical constraints can complicate the supply chain even further.

💭 Final Thought

When someone says:

“AI is growing rapidly.”

don't think only about ChatGPT, Claude or Gemini.

Think about everything underneath them.

AI Applications
↓
AI Models
↓
Inference
↓
GPU / Accelerators
↓
Servers
↓
Data Centers
↓
Semiconductors
↓
Manufacturing

SMIC's latest results are a reminder that the AI revolution is also a hardware revolution.

The companies building the models may get most of the attention.

But underneath every AI model is an enormous physical infrastructure of chips, factories, electricity, cooling systems, networks and engineers.

The future of AI will be written in software—but it will run on silicon. 🧠⚡

Source: Reuters, August 14, 2026. Financial and operational figures in this article are based on the Reuters report.

ai #artificialintelligence #semiconductor #chips #smic #machinelearning #softwareengineering #aiengineering #infrastructure #gpu #technology

Z.ai’s GLM-5.3 Closes the AI Cyber Gap

Tonmoy Chandra Mudi — Sat, 15 Aug 2026 05:20:02 +0000

AI competition is moving into a new battlefield:

Cybersecurity.

Chinese AI startup Z.ai has announced that its new open-source model, GLM-5.3, is approaching Anthropic's restricted Mythos 5 in cybersecurity testing.

According to Z.ai's reported results, GLM-5.3 actually performed slightly better than Mythos 5 at finding software vulnerabilities.

But there is an important catch.

When it came to turning those vulnerabilities into working exploits, Mythos 5 remained significantly ahead.

And that difference tells us something important about where AI cybersecurity is heading.

🧠 What Is GLM-5.3?

GLM-5.3 is a new general-purpose coding model from Chinese AI company Z.ai.

What's interesting is that Z.ai says the model wasn't created purely as a cybersecurity product.

Instead, it reportedly started from the same base model as GLM-5.2 and gained stronger cybersecurity capabilities through:

Extended post-training
Reinforcement learning
Longer task environments
More diverse cybersecurity tasks

That approach is important.

It suggests that increasingly capable general-purpose coding models can develop strong cybersecurity capabilities through additional training, rather than requiring a completely separate security-specific architecture.

🔐 What Is Anthropic's Mythos 5?

Mythos 5 is a version of Anthropic's Claude Fable 5 model with certain cybersecurity safeguards removed.

However, Anthropic hasn't simply released it to everyone.

Access is restricted to vetted organizations.

Why?

Because an AI that can:

Find vulnerabilities
↓
Understand the vulnerability
↓
Develop an exploit
↓
Potentially automate attacks

can be extremely useful for defenders.

But the exact same capabilities could potentially help attackers.

This creates one of the biggest challenges in AI security:

The same capability that helps you defend a system can potentially help someone attack it.

📊 GLM-5.3 vs Mythos 5

Z.ai reported the following results.

Test GLM-5.3 Mythos 5
CyberGym 84.5% 83.8%
ExploitBench 54.4% 78.0%
Attack tasks — 2 hours 105 181
Attack tasks — 6 hours 130 247

There is an important distinction here.

Vulnerability discovery

GLM-5.3 reportedly scored:

84.5%

while Mythos 5 scored:

83.8%

That's extremely close.

In fact, GLM-5.3 was slightly ahead according to Z.ai's reported results.

But vulnerability discovery is only one part of cybersecurity.

💥 Finding a Vulnerability ≠ Exploiting It

This is probably the most important technical distinction in the entire story.

Imagine an AI reviews a web application and discovers:

query = "SELECT * FROM users WHERE id=" + user_input

The model might correctly recognize:

“This code may be vulnerable to SQL injection.”

That's vulnerability discovery.

But a much harder task is determining whether the vulnerability can actually be exploited in the target environment.

That could require understanding:

Application logic
Database configuration
Input validation
Authentication
Network architecture
Permissions
Runtime behavior

So cybersecurity capability can be thought of as a pipeline:

Code
↓
Understand system
↓
Find vulnerability
↓
Verify vulnerability
↓
Develop exploit
↓
Execute attack

GLM-5.3 appears to be very competitive in the earlier stages.

Mythos 5 was substantially stronger in the later stage, according to the reported tests.

⚔️ Why This Matters

A model that can discover vulnerabilities at scale could potentially transform defensive security.

Imagine an organization with:

10,000,000 lines of code

Human security researchers cannot manually inspect every possible path.

An AI coding agent could potentially:

Repository
↓
Static analysis
↓
AI reasoning
↓
Potential vulnerability
↓
Verification
↓
Developer notification

This could make vulnerability discovery much faster.

Instead of waiting for:

“Someone discovered a vulnerability.”

we could move toward:

“The AI continuously searches for vulnerabilities before attackers find them.”

That's a huge shift.

🤖 AI Could Become a Continuous Security Engineer

Traditional security audits often happen periodically.

For example:

January → Security audit
February → Development
March → Development
April → Security audit

AI agents could potentially make security continuous:

Code change
↓
AI reviews code
↓
Finds suspicious behavior
↓
Tests the vulnerability
↓
Creates report
↓
Developer fixes it
↓
AI verifies the patch

This is particularly interesting for open-source software.

Thousands of developers could potentially use AI systems to automatically audit their repositories.

🌍 Open-Weight vs Closed AI

This is where the Z.ai announcement becomes much more interesting.

Anthropic's Mythos 5 is restricted.

Z.ai says GLM-5.3 will eventually be publicly released, although its most sensitive cybersecurity capabilities will reportedly require verified access.

This creates a fundamental debate.

Closed approach

A provider controls:

Model access
Safety filters
Infrastructure
Monitoring
User identity
Usage policies

The advantage is centralized control.

Open-weight approach

Developers can potentially:

Run models locally
Modify them
Fine-tune them
Integrate them into custom systems
Build specialized security tools

The advantage is flexibility.

But there is a major problem.

Once model weights are distributed:

Provider
↓
Model
↓
Developer
↓
Modified Model
↓
Unknown Environment

the original provider may lose control over how the model is used.

🛡️ The Safety Problem

Z.ai says GLM-5.3 includes multiple safety layers, including:

Risky-request screening
Monitoring
Training the model to reject malicious requests

This sounds promising.

But there's an important limitation.

Suppose the model is released with its weights.

A malicious actor could potentially:

Download model
↓
Modify model
↓
Remove safety mechanisms
↓
Connect external tools
↓
Deploy autonomous agent

The original safety layer may no longer provide the same protection.

That's why open-weight AI cybersecurity models are particularly complicated.

🧩 Why Reinforcement Learning Matters

One of the most interesting technical details is Z.ai's claim that cybersecurity capability was improved through additional training and reinforcement learning.

This reflects an important trend in modern AI.

Instead of simply teaching a model:

“Here is a vulnerability.”

you can create environments where the model must perform a sequence of tasks.

For example:

Task
↓
Inspect code
↓
Form hypothesis
↓
Test hypothesis
↓
Receive feedback
↓
Improve strategy
↓
Repeat

This type of environment-based training can teach models to perform multi-step reasoning and agentic tasks.

And cybersecurity is naturally suited to this approach because many security problems are sequential.

💻 Why Developers Should Care

You don't need to become a penetration tester to understand why this matters.

AI-assisted security is becoming increasingly relevant to software engineering.

Developers may increasingly use AI to:

Review code
"Find potential security vulnerabilities in this repository."
Analyze dependencies
"Identify vulnerable dependencies and explain the impact."
Audit APIs
"Review authentication and authorization logic."
Check infrastructure
"Analyze this configuration for security weaknesses."
Validate fixes
"Verify whether this patch actually fixes the vulnerability."

This means security knowledge is becoming increasingly valuable for AI engineers.

🚀 The Future: AI vs AI

Here's where things become really interesting.

Imagine:

         DEFENDER AI
              ↓
      Finds vulnerability
              ↓
         Fixes code
              ↓
      Tests the patch
              ↓
         Deploys

At the same time:

         ATTACKER AI
              ↓
      Searches systems
              ↓
    Finds vulnerabilities
              ↓
      Attempts intrusion

Both sides become increasingly automated.

That means future cybersecurity may become a competition between autonomous AI systems.

The strongest defense may not simply be a better firewall.

It may be:

A better AI security system that continuously understands, tests and protects your software.

🔥 But Benchmarks Need Context

There's one important caveat.

The reported GLM-5.3 results have not been independently verified, according to Reuters.

That means we shouldn't conclude:

“GLM-5.3 is better than Mythos 5.”

The more accurate interpretation is:

Z.ai reports that GLM-5.3 is highly competitive with Mythos 5 on vulnerability discovery, while still trailing significantly on exploit development.

Benchmark methodology, task selection and evaluation environments matter enormously.

Real-world performance can be very different from benchmark performance.

🌐 What This Means for Open Source

If Z.ai successfully releases a capable open-weight cybersecurity model, the consequences could be significant.

Small security teams could gain access to capabilities that previously required expensive security tooling.

Open-source maintainers could potentially use AI to audit projects.

Researchers could experiment with new defensive techniques.

Developers could integrate vulnerability detection directly into their workflows.

But the same technology could also lower the barrier to malicious activity.

That's the fundamental trade-off.

More openness
↓
More innovation
+
More accessibility
↓
But potentially
↓
More misuse
🧠 My Biggest Takeaway

The most interesting part of this announcement isn't that one benchmark score is higher than another.

It's that cybersecurity is becoming a serious capability frontier for AI models.

We're moving from:

AI that writes code

to:

AI that understands code

then:

AI that tests code

and potentially:

AI that continuously secures entire software systems.

That is a much bigger idea.

For software engineers, this means learning AI + security + systems could become an extremely powerful combination.

Because the next generation of developers may not just write software.

They may build software that AI continuously attacks, analyzes, repairs and protects. 🔐🤖

💭 Final Thought

The AI race isn't happening in only one dimension.

It's happening across:

Coding → Reasoning → Agents → Cybersecurity → Infrastructure → Autonomy

And models like GLM-5.3 and Mythos 5 show how quickly these capabilities are converging.

The real question isn't simply:

“Which AI model has the highest benchmark score?”

It's:

“How do we build AI systems powerful enough to protect the internet without making it easier to attack?”

That's going to be one of the defining engineering and security challenges of the AI era.

Source: Reuters, August 14, 2026. The benchmark figures discussed above are claims reported by Z.ai and were not independently verified by Reuters.

ai #cybersecurity #machinelearning #llm #softwareengineering #opensource #artificialintelligence #aiengineering #security #coding

Anthropic’s Road to $2 Trillion

Tonmoy Chandra Mudi — Sat, 15 Aug 2026 05:05:26 +0000

Anthropic, the company behind Claude, is preparing for what could become one of the largest technology IPOs ever. But there’s something particularly interesting about how investors are thinking about its valuation.

According to a recent Reuters report, Anthropic is projecting approximately $190–$200 billion in revenue by 2028.

That number is enormous.

But the more interesting question isn't:

“Can Anthropic make $200 billion?”

It is:

“How do investors decide what Anthropic is worth today based on revenue it might generate two years from now?”

Let's break it down from a technology and business perspective.

🚀 From $9B to $47B+ Revenue Run Rate

Anthropic's growth has been extraordinary.

According to the Reuters report, Anthropic's revenue run rate was approximately:

Period Revenue Run Rate
End of 2025 ~$9B
May 2026 >$47B
Projected 2028 ~$190–$200B

The important concept here is revenue run rate.

A run rate isn't necessarily the same thing as actual annual revenue.

For example, if a company generates $5 billion in a particular quarter, someone might annualize that:

$5B × 4 = $20B annualized run rate

It basically answers:

“If the company continued operating at this current pace, what would its annual revenue look like?”

That distinction matters when evaluating rapidly growing companies.

💰 How Can Investors Value Anthropic?

Traditional companies are often valued using metrics such as:

Revenue
EBITDA
Net income
Free cash flow
Price-to-earnings ratio

But AI companies like Anthropic are unusual.

They're spending enormous amounts on:

GPUs
Data centers
Model training
Model inference
Researchers
Engineers
Cloud infrastructure

So their current profits don't necessarily tell the entire story.

Instead, investors may focus heavily on future revenue.

One common approach is:

Enterprise Value ≈ Revenue × Revenue Multiple

For example, imagine a hypothetical company producing:

$10B revenue

and investors believe companies like it deserve a:

20× revenue multiple

Then:

$10B × 20 = $200B

That gives a rough enterprise value.

Of course, real valuation models are significantly more complicated.

📈 Why 2028 Matters

Here's where Anthropic becomes particularly interesting.

Investors aren't only looking at what Anthropic generates today.

They're asking:

“What could Anthropic look like when the AI infrastructure investment starts producing operating leverage?”

Suppose Anthropic reaches:

$200B revenue

in 2028.

If the market eventually assigns a hypothetical:

10× revenue multiple

the valuation would be:

$200B × 10
= $2 trillion

At:

15×

it becomes:

$200B × 15
= $3 trillion

At:

20×

it becomes:

$4 trillion

These aren't predictions.

They're simply examples showing why future revenue assumptions have such a huge impact on valuation.

🤖 The Real Problem: AI Is Expensive

There's a major difference between building traditional SaaS software and operating frontier AI models.

A normal SaaS application might have relatively predictable infrastructure costs.

AI inference can be dramatically different.

Every time a user sends a request to a large language model, the company potentially needs:

User
↓
API Request
↓
GPU / Accelerator
↓
Model Inference
↓
Generated Tokens
↓
Response

At massive scale, those GPU cycles become a significant operating expense.

And training frontier models requires another enormous investment.

So Anthropic has an important challenge:

Can revenue grow faster than compute and operating costs?

That's one of the biggest questions behind the valuation.

⚙️ The AI Scaling Equation

A simplified way to think about the business is:

Revenue Growth
↓
More Customers
↓
More API Usage
↓
More Inference
↓
Higher Compute Costs

But eventually, investors want something different:

Revenue Growth
↓
More Customers
↓
More AI Usage
↓
Better Hardware + Better Models
↓
Lower Cost per Token
↓
Higher Gross Margin
↓
Operating Leverage

That final transition is extremely important.

If Anthropic can make each unit of AI computation increasingly efficient, revenue could eventually grow much faster than costs.

🏢 Why Cloudflare and Palantir Matter

Reuters reports that investors are considering companies such as Cloudflare, Palantir and SpaceX as reference points.

Why?

Because there isn't a perfect publicly traded company that looks exactly like Anthropic.

Each provides a different comparison.

Cloudflare

Cloudflare represents a high-growth infrastructure/software business.

It helps investors think about:

Infrastructure
Developer platforms
Recurring revenue
High growth
Scaling technology businesses
Palantir

Palantir provides another interesting comparison because of its strong connection to:

Enterprise AI
Government technology
Data platforms
High-growth software
SpaceX

SpaceX is particularly interesting because its valuation is heavily connected to expectations about its future scale rather than simply today's financial results.

🧠 The Bigger Question: Is AI Creating Real Productivity?

This might be the most important question.

AI companies can generate enormous revenue.

But investors eventually need to understand where that money is coming from.

Are businesses paying billions because AI:

replaces expensive manual work?
makes developers significantly more productive?
automates customer support?
improves research?
accelerates software development?
creates entirely new products?

Or are companies simply experimenting with AI because they don't want to fall behind?

There's a huge difference.

If AI produces substantial economic value, enormous valuations could eventually make sense.

If AI spending doesn't translate into proportional productivity gains, valuations could face serious pressure.

⚠️ The Risk Behind a $2 Trillion+ Valuation

A high valuation isn't automatically a problem.

The problem is what assumptions are already priced into it.

Imagine investors value Anthropic at:

$2T

based partly on expectations of:

$200B revenue

That means investors are effectively saying:

“We believe Anthropic can become an enormous, highly valuable business.”

But what happens if revenue reaches only:

$120B

instead of:

$200B

Or compute costs remain extremely high?

Or competitors become stronger?

Or open-source models become good enough for many use cases?

Or AI pricing falls dramatically?

The valuation could change very quickly.

🔥 Why This Matters to Developers

If you're a software engineer, this isn't just Wall Street news.

It affects the technology ecosystem you're building your career in.

The money flowing into AI is influencing:

GPU demand
Cloud infrastructure
AI startups
Developer tools
APIs
Open-source models
AI agents
Data engineering
MLOps
Backend architecture

For developers, the interesting part isn't simply:

“Anthropic might be worth trillions.”

The interesting part is:

“What technology needs to exist for a company like Anthropic to generate $200B of revenue?”

That question leads directly into some of the most important engineering problems of the next decade.

🛠️ What Engineers Should Learn

If you're preparing for a software engineering or AI engineering career, I'd pay attention to these areas:

Python

Still one of the most important languages for AI engineering.

Backend Engineering

Learn how APIs, authentication, databases, queues and distributed systems work.

Cloud Infrastructure

Understand:

Containers
Docker
Kubernetes
Cloud Computing
Networking
Observability

Machine Learning

Learn the fundamentals before jumping directly into frameworks.

Understand:

Linear Algebra
Probability
Statistics
Optimization
Machine Learning
Deep Learning

LLM Engineering

Then move toward:

Transformers
Embeddings
Vector Databases
RAG
Agents
Fine-tuning
Inference
Evaluation

AI Infrastructure

This is where things get particularly interesting.

Learn about:

GPU computing
Distributed systems
Model serving
Inference optimization
Caching
Batching
Quantization

Because eventually, AI engineering isn't just about building models.

It's about making those models economically useful at enormous scale.

🌍 The AI Economy Is Still Being Built

Anthropic's potential IPO is another sign that the AI industry is moving from an experimental technology phase toward a massive commercial infrastructure phase.

But the $190–$200 billion 2028 revenue projection is exactly that:

a projection.

The future depends on many variables:

AI adoption

Enterprise spending
Model capabilities
Compute efficiency
Competition
Pricing
Infrastructure costs
Productivity gains = Future economics of AI

Nobody knows the final answer yet.

And that's what makes this era so interesting.

We're not just watching companies compete.

We're watching an entirely new technology economy being built in real time.

💭 Final Thought

The most interesting number in the Anthropic story isn't actually $200 billion.

It's the assumption behind it.

Investors are effectively betting that AI will become important enough, useful enough, and economically productive enough to support businesses operating at an extraordinary scale.

Whether that bet is correct will depend not only on AI models...

but on engineers building the infrastructure, applications and products that turn those models into real economic value.

And that's exactly why learning AI engineering today is so interesting. 🚀

Source: Reuters, August 15, 2026 — reporting on Anthropic's projected 2028 revenue and IPO valuation framework.
This post is an independent educational analysis and not investment advice.

ai #anthropic #claude #machinelearning #softwareengineering #artificialintelligence #technology #programming #llm #aiengineering