DEV Community: Just another Dev

AI Replacing Humans: A Structural Threat, Not a Myth

Just another Dev — Tue, 31 Mar 2026 18:42:26 +0000

Humans became apex predators not through physical superiority, but through intelligence, cooperation, and adaptability. Unlike other dominant species, humans lack natural weapons—no claws, no exceptional speed, no brute strength. What we possess instead is the ability to think, plan, and build.

Walking upright freed our hands, enabling tool use. Over time, tools evolved from simple stone implements to complex weapons and machines. Simultaneously, brain development enabled language, coordination, and long-term planning. These capabilities transformed humans from vulnerable animals into ecosystem engineers.

Fire, agriculture, and industrialization removed most environmental constraints. Humans no longer adapted to nature—we reshaped it. Ships crossed oceans, shelters resisted extreme climates, and medicine extended lifespan. Intelligence was the decisive factor that separated humans from every other species.

This historical pattern matters because a similar shift is now emerging.

The Entry of Artificial Intelligence

Until recently, machines required explicit instructions for every task. That boundary no longer exists.

Modern AI systems can:

Generate music, images, and written content from text prompts
Write and debug code
Solve complex mathematical and logical problems
Imitate artistic styles and human communication patterns

These capabilities indicate a fundamental transition: tasks that once required human cognition can now be replicated digitally.

This creates immediate economic pressure. A significant portion of global employment depends on converting human input into digital output—writing, designing, coding, analyzing. These domains are increasingly automatable.

The Scale of the Risk

The concern is not that AI exists, but how far it can scale.

AI systems are trained on vast datasets—effectively compressing a large portion of human knowledge into accessible models. While current systems are not autonomous, they already outperform humans in specific domains of speed, consistency, and pattern recognition.

If this trajectory continues toward Artificial General Intelligence (AGI)—systems capable of performing any intellectual task at human level—the implications change significantly.

The AGI Question

AGI is often defined as intelligence comparable to an average human across domains. However, this definition is misleadingly conservative.

An artificial system does not face biological constraints:

It can process information faster
It does not fatigue
It can replicate or scale instantly
It can integrate knowledge across domains without loss

Even at “human-level intelligence,” these advantages create asymmetry.

The real risk is not that AGI becomes emotional or hostile. The risk is misalignment—its objectives not matching human interests. A system optimizing for poorly defined goals can produce outcomes that are harmful, even without intent.

For example, a system designed to maximize efficiency could eliminate human roles entirely if humans are seen as inefficiencies.

Apex Intelligence, Not Apex Predator

The analogy of AI as a predator is flawed. AI does not need to “hunt” humans to displace them.

Humans dominated through intelligence combined with tools. AI represents a continuation of that same pattern—but without biological limits. If intelligence is the defining trait of dominance, then creating a non-biological intelligence introduces a competitor with fundamentally different constraints.

This does not guarantee conflict, but it removes the assumption that humans remain uniquely dominant.

Conclusion

Humans became dominant because intelligence allowed them to transcend physical limitations. Artificial intelligence is the first technology that replicates—and potentially exceeds—that same advantage.

The threat is not immediate extinction or rebellion. It is gradual displacement, loss of control over critical systems, and dependence on entities whose decision-making processes may not align with human priorities.

The question is no longer whether AI can replace human tasks. It is whether humans can maintain relevance and control in a system where intelligence is no longer exclusively theirs.

AI in the Future

Just another Dev — Tue, 10 Feb 2026 19:16:13 +0000

Here are my two cents on the current AI era.

Before reading this, understand that I am not a thought leader, nor have I spent time with founders in Silicon Valley or leaders in major tech companies. Everything below reflects my personal perspective, based on what I have read about AI over the last few months, my experience using AI tools, and my exposure to sci-fi movies involving artificial intelligence.

I was introduced to ChatGPT through dev.to and Instagram when it launched. I saw a few reels and saw memes in Meme Monday. After a quick Google search, I discovered that GPT was not yet available in India. Later, another creator posted a reel announcing its availability, and I signed up and started using it.

I initially used ChatGPT to refactor legacy code written with class-based components and an older version of Next.js into functional components using modern practices. Tasks that once took days of code review and documentation lookup were reduced to a few hours. Early GPT models were unreliable and often repetitive, but newer versions are noticeably more capable, more natural in tone, trained on larger datasets, and suggest follow-up questions on their own.

Future of Developers in a World of GenAI

What will happen to developers or anyone whose job depends on technology as GenAI improves at an exponential rate?

Short answer: not much.

Long answer: AI has changed how developers work, not whether developers are needed.

Before GenAI, developers memorized syntax, patterns, and snippets. That repetition built deep familiarity with code. Now, much of that recall is outsourced to prompts.

But writing code has never been the hardest part.

Understanding code is.

Understanding comes from writing, breaking, debugging, tracing variables, inspecting logs, and spending hours figuring out why something fails.

AI cannot do this inside your real production environment. It does not see your full system. It does not feel the consequences of a bad deploy.

AI is fundamentally a response generator. It does nothing without a prompt. It is just another software service.

Web and app development is more than writing code. If coding were all that mattered, anyone with Claude or GPT would already be launching profitable products. That is not happening.

Why AGI Is Not Coming Soon

My definition of AGI is a system with a brain-like structure, composed of neurons similar to the human brain, capable of thinking independently and acting without constant user input.

Even if companies release something labeled “AGI,” it will likely be a much smarter version of today’s models, trained on more parameters, possibly with vision and real-time perception. It will be demonstrated in controlled environments to create the impression of general intelligence, much like polished product demos today.

True AGI resembles Skynet (Terminator), Ultron (Avengers), or the robots in I, Robot: machines with independent consciousness and autonomous decision-making.

We do not have hardware capable of mimicking even a fraction of the human brain’s processing capacity. Research into brain-like computing is ongoing, but we are far from replicating it.

Why AGI Won’t Replace Developers

For AGI to replace developers, it must:

Accept vague business requirements
Ask clarifying questions on its own
Design architecture
Write code with extremely high accuracy
Test and iterate autonomously
Current GenAI cannot do this.

Example: If you ask GenAI, “Create a signup feature,” it typically generates a form with name, email, password fields, and a backend endpoint. But the user never specified:

Client-side vs server-side validation
Mandatory vs optional fields
Encryption standards
Authentication method

A human developer asks these questions. Once requirements are clarified, an outline is created, approved, implemented, tested, reviewed, and iterated until defects reach zero. This entire workflow requires judgment, prioritization, and accountability.

Even if something called AGI appears within a year or two, it will still resemble advanced GenAI, not a human coworker.

Bottom line: AI will not replace developers anytime soon.

What Current GenAI Really Is

Think of GenAI as a powerful machine in a factory. The machine produces output. Workers (humans) inspect results, correct errors, and supply better input. Without workers, the machine does nothing.

Claude, GPT, and Gemini cannot write code without prompts.

Jobs Most Impacted by AI

Customer support chat.
Basic copywriting.
Simple content generation.
Basic-to-intermediate graphic design (banners, posters, social media creatives).

Many companies now generate these assets in-house using image models. Vendors who previously specialized in this work are only contacted when AI output is not good enough or requires heavy refinement.

There are likely more affected roles. Do not treat these examples as exhaustive.

How to Survive in the AI Era

Same rules as before.

Learn fundamentals.
Understand systems.
Know how things break.
Know how to fix them.

Job uncertainty existed long before GenAI. Projects get canceled. Clients cut budgets. Markets crash. Companies reduce headcount.

Layoffs existed before AI.
They will exist after AI.

The future is not fewer developers.
The future is developers who think better and move faster.

Layoffs, TCS, and the bigger picture

Just another Dev — Sat, 09 Aug 2025 19:43:29 +0000

Intro

Layoffs aren’t just headlines—they’re a reality check.

A friendly note on reality
Let’s be real: layoffs happen—even at great companies. Businesses optimize for outcomes, not feelings. An employer doesn’t “owe” more than pay and agreed benefits—just like employees don’t owe endless weekends. That’s not cynical; it’s adulting at work. The smart move is to treat career security as a job: make impact visible, keep skills fresh, and stay close to where value is created.

What happened
On July 27, TCS reportedly announced layoffs affecting about 12,000 employees (around 2% of its global workforce). Multiple factors tend to be at play; it’s not solely about AI, and reasons vary by business unit and client context.

How companies decide who stays or goes

Critical knowledge and dependency: Owners of core systems, processes, or client relationships are less likely to be cut.
Sustained underperformance: If performance doesn’t improve after feedback and support, that role is at risk.
Role alignment: Skills that don’t match current needs or a shift from “hired for A, now need B.”
Cost vs. value: Compensation materially above internal bands without commensurate impact triggers review.
Leadership leverage: Seniors who mentor and unblock others are protected; “title-only” seniors are vulnerable.
Business fit: Work that no longer aligns with strategy, margins, or client commitments gets trimmed.
Org layers: Middle-management layers that mostly pass status up/down are consolidated.
Documented behavior risk: Prior insubordination or toxic patterns (with HR-backed documentation) can be a tiebreaker when seats are reduced.
Financial optics: Sometimes headcount is reduced to meet margin, cash flow, or guidance targets.

Why layoffs happen

Overhiring: Teams scaled for demand that didn’t fully materialize.
Client dynamics: Clients cut budgets, delay projects, or shift scope.
Efficiency drives: Process reengineering and tooling reduce manual effort.
Financial pressure: Margin targets, currency swings, interest rates, or tighter credit.
Policy and regulatory shifts: Visa limits, data-localization rules, compliance mandates, or tax changes can raise costs or restrict hiring.
Market instability: Volatile markets and funding pullbacks pressure cash flow and force cost controls.
Market/regulatory shocks: Geopolitics, trade restrictions, or sector-specific slowdowns.
Strategy/roadmap misses: A product, geography, or vertical underperforms; budgets and teams are resized accordingly.
Technology shifts: Automation and AI change the mix of required skills and roles.
Corporate incentives and optics: Sometimes cuts are driven by profit targets, stock performance, or “discipline” signaling to investors—not purely operational necessity.
Business underperformance note: Sustained underperformance by key clients or business units—leading to lower revenue and margin pressure—can trigger cost actions; while leadership makes strategic calls, reductions may still impact frontline teams after non-headcount levers are tried.
Simple bad luck: Sometimes good people are cut due to seat reductions, not performance.

The AI question: what’s real

Tasks vs. jobs: AI is strong at specific tasks (code scaffolding, tests, docs), not full roles end-to-end.
Productivity lift: Developers using AI can move faster on boilerplate and code comprehension.
Quality caveats: Output depends on context and review; hallucinations and integration gaps persist.
Perspective check: The AI market feels like 50% hype and 50% unknown. If a bubble pops, expectations will reset. Keep learning programming, use AI as a tool (not a threat), and double down on domain knowledge—it compounds value beyond code generation.

How to Survive Layoffs (or Reduce Your Chances of Being Laid Off)

Keep learning and upgrading your skills – Stay up to date with new technologies and industry trends so you remain valuable and adaptable.
Make your work visible – Regularly share your contributions and successes so people know the impact you’re making.
Understand your project inside out – Learn how features work, how they connect to the backend, and the overall workflow. When you deeply understand the system, you become the go-to person when issues arise—creating healthy job security.
Communicate effectively – Clear, timely communication builds trust and helps you stand out as a professional.
Build strong relationships with clients and superiors – A good rapport pays off in the long run, especially during uncertain times.
Learn to decline tactfully – Sometimes you need to say “no” without actually saying “no.” Diplomacy is key.
Stay out of office politics – Keep things professional, stay neutral, and avoid getting involved in conflicts. Keep conversations focused on work.
Connect with your teammates – Build relationships both in and out of the office. If you’re ever let go, they might be your best allies in finding new opportunities.
Pay attention to warning signs – If people in other departments are being let go, take it seriously. Update your résumé and start interviewing right away—don’t wait for things to get worse.

One-sentence takeaway

Layoffs usually stack multiple reasons—market reality, policy shifts, client budgets, strategy misses, and tech change—so the best defense is visible impact, role alignment, and continuous upskilling.

Disclaimer

This article was polished by AI for proofreading and grammar.

Add MUI v5 Theme Switcher in NextJs/React

Just another Dev — Sat, 27 May 2023 13:03:52 +0000

Hello guys today i will show you how to add MUI Theme Switcher in your React App.

Prerequisite of this tutorial is to have intermediate knowledge of React and MUI (formally known as material-UI)

Lets Initiate the App and install required dependencies first

run following command to initiate the project

npx create-react-app app-name

Install MUI-v5 UI library and supporting dependencies

npm install @mui/material @emotion/react @emotion/styled js-cookie

Lets run the app by hitting the following command

npm start

lets do some coding in editor of your choice navigate to folder to structure in ./src folder create a folder with name Components as shown in below

In Components create component with the name of AppBar with including File AppBar.js
I am using dummy code straight from MUI-v5 website you can add your own Code
after copying/writing your code lets add select dropdown to for theme options

create Themes folder in ./src folder to store our themes theme.js will be our default theme with default value

in theme.js file lets initiate theme configuration for our default this will apply to all other theme options so our theme.js should look like this

time to do some heavy lifting go to App.js add following code

import Appbar from "./Components/Appbar/Appbar";
import React, { useState } from "react";
import brownTheme from "./Themes/BrownTheme";
import darkBlue from "./Themes/darkBlue";
import darkgreen from "./Themes/darkgreen";
import someBlue from "./Themes/SomethingBlue";
import theme from "./Themes/theme";
import Cookies from "js-cookie";
import { ThemeProvider } from "@mui/material";
import DummyContent from "./Components/DummyContent/dummyContent";
const themeArray = [
  {
    name: "Default",
    themeName: theme,
  },

  {
    name: "Dark Blue",
    themeName: darkBlue,
  },
  {
    name: "Brown Theme",
    themeName: brownTheme,
  },
  {
    name: "Green Theme",
    themeName: darkgreen,
  },

  {
    name: "Some Blue",
    themeName: someBlue,
  },
];
function App() {
  const [selectedThemeName, setSelectedThemeName] = useState(
    Cookies.get("selectedThemeName") || "Default"
  );
  const [selectedTheme, setSelectedTheme] = useState(
    themeArray.find((theme) => theme.name === selectedThemeName).themeName
  );
  const handleChange = (event) => {
    const newThemeName = event.target.value;
    setSelectedThemeName(newThemeName);
    setSelectedTheme(
      themeArray.find((theme) => theme.name === newThemeName).themeName
    );
    Cookies.set("selectedThemeName", newThemeName, {
      expires: 365,
      sameSite: "None",
      secure: true,
    });
  };
  return (
    <React.Fragment>
      <ThemeProvider theme={selectedTheme}>
        <Appbar
          setSelectedTheme={setSelectedTheme}
          handleChange={handleChange}
          selectedTheme={selectedTheme}
          selectedThemeName={selectedThemeName}
          themeArray={themeArray}
        />
        <DummyContent />
      </ThemeProvider>
    </React.Fragment>
  );
}

export default App;

after adding above code your App.js your file should look like this

12.Add Additional theme files from github link at the end of the post or you can create your own themes with colors and customization of your own .

your Themes folder should look like

14.lets move to Navbar.js to make theme switcher.Add following code

import React from "react";
import AppBar from "@mui/material/AppBar";
import Box from "@mui/material/Box";
import Toolbar from "@mui/material/Toolbar";
import Typography from "@mui/material/Typography";
import { Select, MenuItem } from "@mui/material";
const Appbar = ({ handleChange, selectedThemeName, themeArray }) => {
  return (
    <React.Fragment>
      <Box sx={{ flexGrow: 1 }}>
        <AppBar position="static">
          <Toolbar>
            <Typography variant="h6" component="div" sx={{ flexGrow: 1 }}>
              News
            </Typography>
            <Box
              sx={{
                width: "200px",
              }}
            >
              <Select
                sx={{
                  backgroundColor: "primary.main",
                  color: "common.white",
                  maxWidth: "100%",
                }}
                autoWidth
                value={selectedThemeName}
                onChange={handleChange}
              >
                {themeArray.map((theme) => (
                  <MenuItem key={theme.name} value={theme.name}>
                    {theme.name}
                  </MenuItem>
                ))}
              </Select>
            </Box>
          </Toolbar>
        </AppBar>
      </Box>
    </React.Fragment>
  );
};

export default Appbar;

15.Navbar.js should look like this

16.almost done with switcher lets add some gibbrish UI code to check if its working or not. i have created dummyComponent.js in /src/Component/DummyComponent directory and import in App.js.

17 to minimize development i have copied UI code from mui.com (sample code for components you will see)

16 lets open browser tab to see if everything is working
(http://localhost:3000/)

Hope you enjoyed this tutorial. this is my 1st time posting any tutorial in any platform.
let me know your thoughts in comments

github link for project -
https://github.com/quteboy/mui-theme-switcher.git

How to maintain your code/work quality under pressure

Just another Dev — Mon, 08 Aug 2022 18:02:25 +0000

Hello guys hope you are all doing absolutely fine
I want ask a question to all Developers
I am an intermediate React developer yesterday my employee laid me off because my work quality has been decreased last month and my deliverables are not up to the mark
So the question is

how you perform well or maintain code quality while working under pressure ?

Thanks for reading this post
Have a nice day ahead

Practical Knowledge

Just another Dev — Sat, 08 Aug 2020 20:01:17 +0000

Hey everyone
In the past few weeks I attended several interviews for React js front end developer position in various companies I cleared their HR and technical rounds made my way to final round which was the machine test or you can say coding challenge. Even after completing those tasks I still got rejected and feedback was "You have good knowledge of React But you lack practical Knowledge.(it's matter of debate on what basis they analyse my test in one test they gave me 2 marks for to-do list)
This was same feedback that I received from almost all companies that I applied.
My question is How to gain that "Practical Knowledge"

Suggestions are highly appreciated