DEV Community: Amit Shrivastava

From Writing Code to Teaching AI: The Rise of the AI-Assisted Developer

Amit Shrivastava — Mon, 12 Jan 2026 16:00:48 +0000

From Writing Code to Teaching AI: The Journey of an AI-Assisted Developer

AI is no longer a future concept—it’s already woven into our everyday lives. Like many others, I’ve joined this journey of understanding and mastering AI, not out of fear, but out of curiosity and intent.

AI in Everyday Life: From Convenience to Dependence (in a Good Way)

On a personal level, I use ChatGPT extensively, including the Pro version, and it has become part of my daily routine. From getting quick answers and thoughtful suggestions to handling practical tasks like creating spreadsheets or managing my monthly budget, AI has significantly reduced everyday friction.

What surprised me most is how naturally it blended into family life. It helps my kids with their homework and school projects—not by replacing learning, but by guiding them. At home, AI feels less like a tool and more like a capable assistant that’s always available.

AI at Work: From Cautious Experimentation to Official Adoption

Professionally, my interaction with AI started cautiously. I used ChatGPT for work-related reasoning and problem-solving, but always in a filtered way—being mindful of not sharing any official or sensitive data on public platforms.

Recently, that changed. My organization officially began adopting AI tools for R&D and development, and that’s when AI moved from the sidelines to the core of my workflow. Tools like Cursor and GitHub Copilot are now part of daily development.

The impact was immediate.
Productivity, Reimagined

With AI handling repetitive coding, boilerplate logic, and routine tasks, my focus has shifted to higher-value work:

Architectural decisions
Complex problem-solving
Code quality and maintainability
Continuous learning

My productivity didn’t just increase—it evolved. And it continues to improve as I get more comfortable working with AI rather than around it.

AI isn’t replacing engineers.
It’s amplifying what good engineers already do.

Fear vs Reality: AI Isn’t the Enemy

Scroll through social media today and you’ll see a pattern—every second or third post talks about AI taking jobs or making roles obsolete. I’m not an AI expert, but based on my experience so far, I believe this fear is misplaced.

We didn’t fear calculators when we stopped doing long calculations by hand.
We didn’t fear computers when ledger books disappeared.

AI is simply the next step in that evolution.

The real risk isn’t AI—it’s resisting change.

From Language-Centric to AI-Assisted Development

I’m primarily a .NET developer, working with Microsoft technologies. My journey started with learning C, evolved through multiple frameworks and platforms, and today has led me to learning AI.

At this point, I don’t see myself as just a .NET developer anymore. I see myself evolving into an AI-assisted developer.

Learning new programming languages still matters—but mastering how to:

Provide AI with the right context

Teach it to your system architecture

Customize it for your frameworks and workflows

Use it to reason about code

…is becoming even more important.

The Real Differentiator: AI Customization

Looking ahead, I strongly believe that AI customization will be the key differentiator. Developers who can teach AI to understand their requirements, systems, frameworks, and constraints will scale faster than those who treat AI as a generic code generator.

Regardless of the programming language, this is how we scale both productivity and skills in the years to come.

The future isn’t AI vs Developers.
It’s Developers + AI, working smarter togethe

Simplifying Complex Logic with JSONLogic in React

Amit Shrivastava — Wed, 11 Oct 2023 07:28:32 +0000

Introduction

When building dynamic applications in React, you often encounter complex logic that involves conditions, calculations, and decision-making. Handling these intricacies can be challenging, but there's a powerful tool that can make your life easier: JSONLogic.

In this article, we'll explore how to leverage JSONLogic in React to simplify complex logic. We'll build an arithmetic calculator as an example, showcasing how JSONLogic can streamline calculations and decision trees.

Prerequisites

Before diving into JSONLogic, ensure you have the following prerequisites:

Basic knowledge of React
Node.js and npm installed on your machine

Setting Up the Project

We'll start by setting up a new React project. You can create one using the Create React App or your preferred setup method. If you need guidance on setting up a React project, refer to the official React documentation.

What is JSONLogic

JsonLogic isn’t a full programming language. It’s a small, safe way to delegate one decision. You could store a rule in a database to decide later. You could send that rule from back-end to front-end so the decision is made immediately from user input. Because the rule is data, you can even build it dynamically from user actions or GUI input.

JsonLogic has no setters, no loops, no functions or gotos. One rule leads to one decision, with no side effects and deterministic computation time, refer to the official JsonLogic Website.

Installing the JSONLogic Library

To work with JSONLogic in our React project, we'll need the json-logic-js library. You can easily add it using npm:

npm install json-logic-js

Simplifying Logic with JSONLogic

The JSONLogic Advantage
JSONLogic is a lightweight and expressive logic language that excels at handling complex conditions, calculations, and decisions. It's especially valuable when you need to make data-driven choices in your applications.

Building an Arithmetic Calculator

Creating the Calculator Component
Now, let's create a new component for our arithmetic calculator. We'll call it ArithmeticCalculator.js. In this component, we'll define the calculator's user interface and logic.

import React, { useState } from 'react';
import jsonLogic from 'json-logic-js';
import Table from 'react-bootstrap/Table';
import Form from 'react-bootstrap/Form';
import Button from 'react-bootstrap/Button';

const ArithmeticCalculator = () => {
  // State variables for result, operation, and input values
  const [result, setResult] = useState('');
  const [operation, setOperation] = useState('+');
  const [value1, setValue1] = useState(0);
  const [value2, setValue2] = useState(0);

  // Event handler for changing the operation
  const handleOperationChange = (e) => {
    setOperation(e.target.value);
  };

  // Event handler for input changes
  const handleChange = (e) => {
    const { name, value } = e.target;
    if (name === 'value1') {
      setValue1(value);
    } else if (name === 'value2') {
      setValue2(value);
    }
  };

  // Event handler for calculation
  const handleSubmit = () => {
    const jsonExp = `{"${operation}": [{"var": "value1"}, {"var": "value2"}]}`;
    const inputData = {
      value1: parseFloat(value1),
      value2: parseFloat(value2),
    };

    const result = jsonLogic.apply(JSON.parse(jsonExp), inputData);
    setResult(JSON.stringify(result));
  };

  // Render the calculator UI
  return (
    <div>
      {/* ... (component JSX code, as shown in the refactored example) ... */}
    </div>
  );
};

export default ArithmeticCalculator;

Handling User Input and Dynamic Logic

Inside the calculator component, we'll use React state hooks to manage the state of the calculator, including the selected operation and input values. Event handlers will update the state as users interact with the calculator. When the "Calculate" button is clicked, JSONLogic will come into play, simplifying the arithmetic operation.

Utilizing JSONLogic

In our calculator example, JSONLogic will simplify complex logic into a concise and human-readable format. It will handle the dynamic calculation based on user input and the selected operation.

Try It Out

To use the calculator, enter two values in the input fields, select an operation from the dropdown, and click "Calculate." JSONLogic will perform the operation, and the result will be displayed instantly. The source code is available at our git repository

Conclusion

In this article, we've explored the power of JSONLogic in simplifying complex logic in React applications. JSONLogic allows you to express intricate conditions and calculations in a clear and concise way. Whether you're building a calculator or tackling more complex scenarios, JSONLogic can be your go-to tool for handling dynamic logic.

Embracing the Digital Age: An Introvert's Perspective on Professional Social Engagement

Amit Shrivastava — Sun, 01 Oct 2023 08:51:15 +0000

As an introvert with more than 14 years of experience in the software profession, I often find myself reflecting on the bustling world around me. It's a world where individuals are relentlessly focused on doing anything and everything to stay relevant and thrive. They're writing blogs, crafting articles, producing captivating reels, and creating engaging YouTube videos, all in the pursuit of recognition and influence in their respective fields. It's not just about entertainment; this eagerness for self-promotion extends across professions, from Chartered Accountants and Financial Consultants to Entrepreneurs and Engineers. Many of us can relate to this ever-increasing demand for visibility and presence.

But, as they say, time waits for no one, and we must keep pace with the rapidly evolving landscape of our digital age. I'm not entirely sure why I'm penning down these thoughts, but it's been on my mind for a while now. I've felt the urge to join the social bandwagon, to engage, to share, and most importantly, to learn and connect with my professional peers. My aim is to make meaningful contributions to my professional community, and I believe that now is the time to do just that.

In this era of constant connectivity, we introvert, often labelled as reserved or shy, have a unique perspective to offer. We're deep thinkers and keen observers, and we excel at listening and processing information. While we may not be the ones to grab the spotlight at a conference or post daily updates on social media, we possess valuable insights and a wealth of knowledge to share.

The digital realm offers introverts a comfortable platform to express themselves. We can write thoughtful blog posts, engage in meaningful discussions on LinkedIn, and share our expertise through articles and videos, all while staying true to our introverted nature. It's not about competing with the extroverts; it's about finding our voice and making our mark in the online professional community.

So, if you're like me, an introvert who's been considering a more active role in the digital age, I encourage you to take that leap. Embrace the opportunities that social engagement offers, whether it's through writing, video content, or even thoughtful comments on industry discussions. Let's learn from one another, contribute our unique perspectives, and make our presence felt in the ever-evolving professional landscape.

The world is changing, and it's time for us introverts to evolve along with it, finding our place in the digital tapestry that connects professionals across the globe. Together, we can create a space where introverts shine just as brightly as their extroverted counterparts, making meaningful contributions and fostering enriching connections in our professional journey.

Integrating the OpenAI API into a C# Project with Visual Studio

Amit Shrivastava — Sat, 30 Sep 2023 21:48:43 +0000

Do you want to harness the capabilities of artificial intelligence to generate human-like text for your applications? The OpenAI API offers a powerful solution for such tasks, and in this guide, we'll take you through the steps of integrating the OpenAI API into a C# project using Visual Studio Community Edition.

Prerequisites

Before we dive into the implementation, make sure you have the following prerequisites:

Visual Studio Community Edition: You'll need this fully-featured Integrated Development Environment (IDE) for C# development. If you haven't already installed it, you can download it from the Visual Studio website.
.NET SDK: Ensure that you have the .NET SDK installed on your machine. You can download it from the .NET website.
OpenAI API Key: Sign up for an OpenAI account and obtain your API key from the OpenAI website.

Step 1: Create a New C# Project

Let's begin by setting up a new C# project:

Open Visual Studio Community Edition.
Click on "Create a new project."
In the "Create a new project" dialog, select "Console App (.NET Core)" under "C#." Choose a project name and location, and then click "Create."

Step 2: Install the OpenAI NuGet Package

The OpenAI .NET library simplifies interactions with the OpenAI API. Here's how to install it:

In the Solution Explorer, right-click on your project and select "Manage NuGet Packages."
In the NuGet Package Manager, search for "OpenAI" and click "Install" to add the OpenAI package to your project.

Step 3: Writing the Code

With the OpenAI package installed, you can start writing C# code to interact with the OpenAI API. Here's an example of how to generate text using the API:

using OpenAI_API;
using OpenAI_API.Completions;

class Program
{
    static async Task Main(string[] args)
    {
        var openAiApiKey = "YOUR_API_KEY"; // Replace with your OpenAI API key

        APIAuthentication aPIAuthentication = new APIAuthentication(openAiApiKey);
        OpenAIAPI openAiApi = new OpenAIAPI(aPIAuthentication);


        try
        {
            string prompt = "Once upon a time";
            string model = "text-davinci-003";
            int maxTokens = 50;

            var completionRequest = new CompletionRequest
            {
                Prompt = prompt,
                Model = model,
                MaxTokens = maxTokens
            };

            var completionResult = await openAiApi.Completions.CreateCompletionAsync(completionRequest);
            var generatedText = completionResult.Completions[0].Text; //completionResult.Choices[0].Text.Trim();

            Console.WriteLine("Generated text:");
            Console.WriteLine(generatedText);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Don't forget to replace "YOUR_API_KEY" with your actual OpenAI API key.

Step 4: Run the Application

With your code in place, you can now run your C# application:

Click on the "Start" button in the toolbar, or press F5 to build and execute your C# application.
Your application will send a request to the OpenAI API, and the generated text will be displayed in the console.

Congratulations! You've successfully integrated the OpenAI API into your C# project using Visual Studio Community Edition. You now have the power to generate human-like text for various applications, from chatbots to content generation.

Remember to handle errors and explore the OpenAI API documentation for more advanced features and options. Happy coding!