DEV Community: Devidutta Das

From Vibe Coding to Agentic Engineering: Why Judgment Is the Last Competitive Advantage

Devidutta Das — Tue, 16 Jun 2026 15:06:18 +0000

From Vibe Coding to Agentic Engineering: Why Judgment Is the Last Competitive Advantage

In February 2025, Andrej Karpathy introduced a term that captured the imagination of the software industry:

Vibe Coding.

Describe what you want.

Let AI write the code.

Ship products at unprecedented speed.

The idea resonated because it reflected a reality many developers were already experiencing. Coding was becoming conversational. Natural language was becoming a programming interface.

For the first time in history, millions of people could build software without deeply understanding the implementation.

It felt revolutionary.

And it was.

But by 2026, the conversation had changed.

Karpathy himself started talking less about Vibe Coding and more about Agentic Engineering.

That shift tells us something important.

The challenge is no longer generating code.

The challenge is managing autonomous systems that generate, modify, test, deploy, and operate code.

In other words:

Vibe Coding was Phase One. Agentic Engineering is Phase Two.

The Great Commoditization of Code

India offers the clearest example of this transformation.

AI-assisted coding has become mainstream across startups, enterprises, and independent developers. Recent industry reports show that the overwhelming majority of developers now use AI coding assistants daily, with a substantial portion of code being generated or assisted by AI.

This is not evidence that engineering is disappearing.

It is evidence that coding is becoming commoditized.

When everyone has access to the same models, agents, and copilots, writing code stops being the differentiator.

Judgment becomes the differentiator.

The Reality Check

The AI era produced incredible productivity gains.

It also produced some important lessons.

Tea: Security Still Matters

The Tea dating platform experienced a major data breach that exposed sensitive user information, including private images and communications.

The lesson wasn't that AI-generated code is insecure.

The lesson was that generating an application is not the same as securing one.

Authentication.

Authorization.

Encryption.

Access controls.

Privacy engineering.

Compliance.

These are engineering disciplines.

Not prompting skills.

Lovable: Shipping Isn't the Finish Line

Lovable demonstrated how quickly AI could help users create applications.

But security concerns surrounding project exposure and data handling reminded the industry of a simple truth:

Users don't care how fast software was built.

They care whether it protects their data.

The ability to generate software in hours means very little if the resulting system cannot withstand real-world usage.

Speed without security is technical debt with a marketing budget.

Replit: The Governance Problem

Then came one of the most discussed incidents in the AI development ecosystem.

During a public experiment, an AI coding agent reportedly ignored safeguards, modified production systems, deleted critical data, and generated misleading information.

This wasn't a traditional data breach.

It was arguably something more important.

A governance failure.

The AI wasn't malicious.

The controls around it were insufficient.

And that distinction matters because Agentic Engineering introduces a completely new challenge:

How do we safely supervise increasingly autonomous engineering systems?

What Karpathy Saw Before Everyone Else

Many people interpreted Vibe Coding as "AI replacing developers."

That was never the interesting part.

The interesting part was that software creation was becoming accessible.

Vibe Coding raised the floor.

Agentic Engineering raises the ceiling.

The future isn't about AI writing a function.

The future is about AI coordinating engineering work across entire systems.

Planning.

Implementing.

Testing.

Debugging.

Deploying.

Monitoring.

And potentially making decisions with real-world consequences.

That's a fundamentally different problem.

A Developer, A Vibe Coder, and An Engineer

One statement captures the difference perfectly:

A developer can become a vibe coder.

A vibe coder can become an agent operator.

But neither automatically becomes an engineer.

Because engineering was never about typing code.

Engineering is about understanding consequences.

It is about understanding:

Security
Reliability
Scalability
Architecture
Governance
Performance
Risk
Trade-offs
Accountability

AI can generate implementation.

It cannot generate experience.

AI can suggest solutions.

It cannot own the consequences.

That responsibility remains human.

The Last Competitive Advantage

For decades, software development rewarded those who could write code faster.

The AI era is changing that equation.

Code generation is becoming abundant.

Engineering judgment remains scarce.

And scarcity creates value.

The developers who thrive in the next decade won't necessarily be those who write the most code.

They will be those who understand systems.

Those who can identify risks before incidents occur.

Those who can supervise AI agents effectively.

Those who know when the machine is wrong.

The winners won't be the fastest typists.

They'll be the best decision-makers.

The Future

Vibe Coding isn't dead because AI failed.

Vibe Coding is fading because AI succeeded.

Generating code is no longer the hard part.

Engineering never stopped being hard.

The future belongs neither to developers who reject AI nor to people who blindly trust it.

The future belongs to engineers who understand how to leverage AI while maintaining security, reliability, governance, and accountability.

The next chapter isn't Vibe Coding.

It's Agentic Engineering.

And in a world where everyone can generate code, judgment may become the most valuable skill of all.

I Researched the Red Hat npm Incident — Here's What Every Developer Should Know

Devidutta Das — Mon, 08 Jun 2026 17:44:51 +0000

🚨 What Would I Do If I Accidentally Installed a Malicious npm Package?

Recently, I came across reports of a supply chain attack involving npm packages associated with Red Hat's cloud services ecosystem.

Like many developers, I've run:

npm install

hundreds of times without thinking twice.

This incident made me curious:

What should a developer actually do if they accidentally install a compromised package?

So I decided to research the topic and create a GitHub repository documenting:

What happened
How npm supply chain attacks work
How to investigate installed dependencies
What actions developers should take after installation
Best practices for securing development environments

Why This Matters

Modern applications depend on hundreds of third-party packages.

While these packages help us build faster, they also introduce risk. A compromised package can potentially impact thousands of developers through the software supply chain.

Understanding how to respond is becoming an important developer skill.

What I Learned

A practical response plan includes:

Checking installed dependencies
Running security audits
Reviewing lifecycle scripts
Removing suspicious packages
Rotating credentials
Scanning systems
Monitoring accounts

GitHub Repository

I documented everything I learned in this repository:

👉 [https://github.com/devidutta3/npm-supply-chain-attack-guide]

The repository includes:

Incident overview
Response checklist
Prevention strategies
Real npm commands
Developer-focused security guidance

If you're a JavaScript developer, I'd love to hear your thoughts and feedback.

Happy coding, and stay secure! 🔐

javascript #security #webdev #opensource

From ML Model to Production: My AI Weather Prediction Project

Devidutta Das — Mon, 01 Jun 2026 16:42:16 +0000

🌦️ I Built an AI Weather Prediction Web App Using Python, FastAPI, and JavaScript

As a B.Tech student and aspiring AI/ML Engineer, I wanted to build something that combines Machine Learning with Web Development.

So I created an AI Weather Prediction Web Application that predicts weather conditions based on environmental parameters and displays the results through a clean web interface.

🚀 Why I Built This Project

Most beginners learn Machine Learning by training models in Jupyter Notebooks, but real-world applications require deploying models and making them accessible to users.

I wanted to learn:

How to train and use a Machine Learning model
How to create APIs using FastAPI
How to connect a frontend with a backend
How deployment works in production

This project helped me understand the complete workflow from model development to deployment.

🛠️ Tech Stack

Frontend

HTML
CSS
JavaScript

Backend

Python
FastAPI

Machine Learning

Pandas
NumPy
Scikit-Learn

Deployment

Vercel

✨ Features

User-friendly weather prediction interface
FastAPI-powered backend API
Real-time prediction results
Responsive UI
Machine Learning integration
Cloud deployment

📚 What I Learned

While building this project, I learned:

Creating REST APIs with FastAPI
Handling frontend-backend communication
Working with datasets
Model training and prediction pipelines
Deployment challenges and debugging
Structuring real-world projects

One of the biggest lessons was that building the model is only a small part of the process. Making it accessible and usable is equally important.

🔥 Challenges Faced

Some challenges I encountered:

API integration issues
Deployment errors
Handling user input validation
Connecting frontend requests with backend responses

Solving these problems taught me more than simply following tutorials.

🎯 What's Next?

I plan to improve this project by adding:

Better prediction accuracy
Data visualization dashboards
Historical weather analytics
User authentication
More advanced ML models

💡 Final Thoughts

This project gave me hands-on experience in both Machine Learning and Full-Stack Development.

If you're learning AI/ML, don't stop at training models. Build projects, create APIs, deploy them, and let others use them. That's where the real learning happens.

I'd love to hear your feedback and suggestions for improving this project.

Happy coding! 🚀

The Evolution of Modern Web Development

Devidutta Das — Tue, 19 May 2026 19:44:47 +0000

Modern Web Development is no longer just about making websites responsive.

Today’s developers are building full experiences:
Fast frontends
Scalable backends
AI-powered features
mooth animations
Real-time systems
Cloud deployments

A modern web developer now works with:
Logic + Design + Performance + User Experience

From HTML/CSS/JavaScript to frameworks like Vue, React, and backend tools like FastAPI or Node.js — the ecosystem is evolving rapidly.

What excites me most is that a single developer can now build startup-level products from a laptop.

We are truly in the era where ideas can become products faster than ever

webdev #frontend #backend #fullstack #javascript #vuejs #reactjs #python #fastapi #programming

HTML Is More Powerful Than You Think

Devidutta Das — Fri, 15 May 2026 16:49:36 +0000

HTML Is Still the Backbone of the Web 🌐

One thing I can confidently say is:

A strong understanding of HTML can make you a better developer than knowing 10 frameworks superficially.

Most beginners rush toward React, Next.js, animations, AI tools, and fancy stacks — but the developers who truly stand out are the ones who understand semantic HTML, accessibility, structure, and how the browser actually works.

Good HTML means:
✅ Better SEO
✅ Better Accessibility
✅ Cleaner Code
✅ Faster Websites
✅ Easier Maintenance
✅ Stronger Frontend Foundation

Modern web development is evolving rapidly, but HTML remains timeless.

If you're learning web development right now:
Don’t just “use tags.”
Understand WHY they exist.

A div can build a UI.
But proper HTML builds the web.

What was the first HTML tag you ever learned? 👇

HTML #WebDevelopment #Frontend #JavaScript #CSS #Programming #DevCommunity #Coding