DEV Community: Abhinav

What is Monorepo ?

Abhinav — Mon, 22 Jun 2026 02:50:00 +0000

Have you ever built a full-stack application (without fullstack framework like NextJS), if yes so you might definitely know that you need to build two projects (frontend and backend) and need to write and build everything separately for both of them. But a monorepo allows to handle that development process more efficiently so that we do not need to build same utility repeatedly.

A monorepo is a single repository containing multiple distinct projects, with well-defined relationships. It is a standard method of using multiple projects in one repository or folder.

Companies like Google, Meta, Microsoft, and Uber uses monorepos to streamline software development across their diverse product suites. Modern companies often require a complex ecosystem of software, including web applications, APIs, Android and iOS apps, and testing suites. Managing these projects in isolation frequently leads to inefficiencies; teams often operate in isolation, unaware of redundant efforts pilling up or shared utility requirements. Furthermore, since frontend applications and APIs are inherently interdependent, a monorepo approach facilitates better integration, fosters code reuse, and significantly accelerates both development cycles and CI/CD pipelines.

Isn't it clutter everything if used in same place?

That's where tools like pnpm/npm/yarn/bun workspaces with Nx or Turborepo helps. These tools allows to structure monorepo, define relations, define ownership, configure CI/CD pipelines with workspace. Whereas you can use both of them separately as well, package managers for package management and tools for task management. But together they provide packages and task management that helps in overall development of project.

what is workspace ?

It generally means that you have a Container that contains everything which your company needs in a monorepo form/structure. These workspaces are highly effective in establishing relations, allowing centralized or individual access of projects.

Does monorepo builds everything, regardless of which part changed?

No, that is not how a monorepo works; a monorepo is not the same as a monolith. Monorepos actually provide excellent isolation and efficiency. For example, if Team A is working on Project A, and it has no dependencies or shared state, it remains completely independent. If Team B makes changes to Project B, the monorepo will only rebuild Project B, leaving Project A untouched. Furthermore, if Project C depends on Project B, the system will only update Projects B and C to reflect those changes.

I get it what is Monorepo but how to use it ??

Their are various tools available that allows to use Monorepo in your project such as: Nx and Turborepo combined with a package manager of your choice (pnpm is standard choice), all package managers supports workspaces so that you can add and link packages in your monorepo seamlessly. Based on your requirements, you can opt for Turborepo (popular one) or Nx (more professional one).

Here's a comparison of both Turborepo and Nx to make a informed choice:

Feature	Turborepo	Nx
Philosophy	Minimal	Full featured
Ease	Easy to Use	Needs detailed setup
Configuration	Minimal (`turbo.json`)	Moderate (`nx.json`, `project.json`)
Primary Goal	Fast task running & caching	Full monorepo platform & governance
Ecosystem Support	JS/TS-based	Native/Plugin-based (Go, Rust, etc.)
Code Generation	Template-based (basic)	Advanced (AST-aware, programmatic)
CI/CD	Efficient task caching	Advanced distribution (Nx Agents)

If you aren't sure, start with Turborepo. It is much easier to start with and provides 80% of the value (caching and fast task execution) for most teams. If you eventually reach a point where you feel "boxed in" or need stronger architectural guardrails and advanced CI features, you can migrate to Nx.

Conclusion

Monorepos are a highly efficient architectural choice in software development, enabling teams to work faster and more effectively. Tools like Turborepo have made this approach accessible to smaller teams as well. Companies like Google and Microsoft have even developed their own custom monorepo solutions, such as Bazel and Rush., respectively to handle their codebase scale. This highlights the proven effectiveness and scalability of the monorepos.

Have you ever used a monorepo? I’d love to hear about your experience in the comments below.

Thanks for reading! ❤️

Abhinav.

A Memory Game to enjoy this summer

Abhinav — Sun, 21 Jun 2026 12:48:46 +0000

This is a submission for the June Solstice Game Jam

What I Built

This is summer time, the time of joy, happiness, enjoyment, energy and mostly football.

Yeah, the World Cup is here and I love football, so I decided to make a game on it, a memory matching game with a FIFA 2026 theme. This is a game to enjoy a moment of energy and the joy of the World Cup. I tried to add FIFA-based theming and styling.

There are various elements I tried to add in the game: the legends' jerseys, Argentina's ball, hosting FC logos and many more.

To elevate the memory game formula, I introduced custom combo multipliers, rich audio triggers, and a real-time global leaderboard. This is just a small project of mine to enjoy the joy of the World Cup using a mini-game.

Video Demo

Here's a video walkthrough of game:

Code

Game is open-sourced and all code is available, you can tweak it, add more elements on it and play it.

AbhinavTheDev / card-match

⚽ Card Match — FIFA Memory Game

A fast-paced football-themed memory card matching game built with React + Vite, featuring a live global leaderboard powered by Firebase.

Built for the June Solstice Game Jam on DEV Community.

🎮 Gameplay

Flip cards to find matching pairs of FIFA-themed icons — FIFA Cup, Argentina Ball, Golden Boot, and more. Race against the clock and try to clear the board before time runs out.

Rules

You have 60 seconds to match all 9 pairs (18 cards)
Each card flip costs an attempt point on a mismatch (max 10 per pair)
A match score is calculated as: attempts_remaining + 1 per pair
Your final score is total_match_score × time_remaining
Combos give bonus points for chaining specific matches

🛠️ Tech Stack

Layer	Technology
Framework	React 19 + Vite 8
Auth	Firebase Authentication (Google + Anonymous)
Database	Cloud Firestore
Animations	canvas-confetti
Package Manager	Bun
Styling	Vanilla

…

View on GitHub

You can play the game from here: Play Now

How I Built It

The application was built from scratch using a modern, lightweight web tech stack focusing on performance, modular design, and most importantly using Antigravity.

Technical Stack

Frontend Core: React 19 + Vite for quick scaffolding, fast builds, and Hot Module Replacement (HMR).
Styling: Vanilla CSS (custom design system utilizing CSS Custom Properties/Variables for state-dependent themes, glassmorphic card layouts, and transforms for flip animations).
Backend-as-a-Service: Firebase v12 for authentication (Google Identity Provider + Anonymous sign-in) and real-time database querying (Cloud Firestore).
Effects: canvas-confetti for lightweight confetti animation.

Technical Decisions & Challenges

Interactive Card Flip: Instead of relying on bulkier external visual libraries, we built custom card components with CSS 3D perspective, preserve-3d, and backface-visibility. This achieved smooth card flip animations across both mobile and desktop browsers.
Leaderboard Optimizations: To maintain a fast, clean leaderboard, Firestore records are queried using compound indexes sorting by score in descending order and limiting responses to the top 10 items.
Adaptive User Experience: The app offers a seamless transition between Guest mode and Google Auth. If a user logs in via Google, their high score, profile photo, and display name are automatically synced to Firestore; guest players can enjoy the full gameplay loop immediately without sign-in friction.

Prize Category

For this project, I am submitting to the Best Google AI Usage category. The development of this game was accelerated and optimized by pair-programming with Antigravity IDE, a powerful agentic IDE, powered by Gemini models.

How Antigravity helped me in development

Scaffolding & Architecture: Antigravity helped architect the project layout, dividing components into focused, reusable files (such as Card.jsx, Modal.jsx, and Login.jsx) and setting up custom hooks (useConfetti.js) for visual effects.
Firebase & Security Rules Integration: Antigravity generated the clean Firebase service wrapper (firebase.js), implementing robust asynchronous logic for Google Sign-in Popups, Anonymous logins, and Firestore read/write operations for saving scores.
Vanilla CSS Design System: Sourcing design guidelines from the frontend design skill, Antigravity guided the implementation of modern CSS elements, introducing glassmorphism UI cards, animated overlays, custom-themed score bars, responsive media query breakpoints, and custom styled webkit scrollbars.
Bug Prevention & Optimization: The gemini helped me to debug timing loops, handling proper interval cleanups on unmounts, and much more minor bugs.

Using Antigravity, I was able to build, style, and wire up a database-driven game in a fraction of the usual development time, showcasing the sheer power of Gemini developer tools.

Do let me know your experience with game in comments below!

Thank You For Reading.

Bigger llm models will no longer be performant

Abhinav — Tue, 02 Jun 2026 03:00:00 +0000

Recently, I came across an essay titled "On the Death of Scaling" by Sara Hooker (Co-founder of Adaption Labs). In this essay, Sara explains the shortcomings of the simple path followed by frontier labs to lead the market. She discusses where the notion of "scaling is death" comes from and what to consider next.

In the last decade, where LLMs are emerging as the ideal path to attaining AI, or what experts call AGI, they have been found to be not so accurate. All LLM-based labs are following one brute force rule of adding more and more weights with more compute to outperform other available models, and up to a certain point, it is helping. Using more compute and data, LLMs are outperforming their predecessors and competitors. But now, the landscape is changing. It has been found that much smaller, latest models (<13B) are now outperforming previous models with enormous parameters. For example, Falcon 180B is easily outperformed by models like Llama 3 8B, Command R 35B, and Gemma 3 27B. Additionally, Aya 23 8B and Aya Expanse 8B have outperformed BLOOM 176B with 94% less weights.

From the above image of the HuggingFace OpenLLM Leaderboard, it is shown that smaller models are significantly outperforming larger ones, both reaching a performance plateau (as transformers' performance reaches its plateau). Hence, it is proven that a bigger size does not always guarantee better performance.

Reason behind such huge number of parameters ?

Surprisingly, almost all earlier LLM models are launching with an increased number of parameters (10x, 100x, etc.), but no one clearly explains the reason behind such a huge number of weights. Do we really need that many weights? Are models only focused on size as a performance metric, bigger size confirms better performance? One of the first widely adopted deep neural network architectures was Inception Net (proposed by Google in 2014), which had only around 23 million weights. But nowadays, a base model like Qwen3-235B-A22B comes with 235 billion parameters.

LLM weights began to increase when a strange observation of double descent was noted in LLM model training. Mathematically, after reaching a certain threshold, the model starts to "overfit" on data, and from this point onward, increasing model complexity leads to decreased performance. However, a surprising observation showed that neural networks do not exhibit this phenomenon. These models now have millions of parameters, more than enough to fit even random labels, yet they perform much better on many tasks than smaller models. This behavior remains a black box, with no one able to explain why it occurs mathematically.

Another observation is that after training a neural network, it is found that 95% of the work is done by a small set of weights, while the rest are additional parameters.

But now the question arises: why do we need such a large number of additional parameters? Can't we train only these few sets of weights and achieve the same performance? The answer is no. It has been shown that if you want to achieve the same performance as a trained model, you need to train the model again with the same number of weights. It is strange but true. The reason behind this behavior is the inefficient and unoptimized training mechanisms (or architectures) used by researchers. Therefore, those seemingly unnecessary weights become a critical part of the model and the reason for its large size.

Deep Neural Networks

Deep Neural Networks, or Deep Learning Networks, are at the heart of all LLM models you are using now. However, they are incredibly inefficient learners. A deep learning network can easily understand common facts but cannot comprehend rare facts in the same way. Essentially, all deep learning networks rely on data, and each data point receives equal learning space, so common facts benefit from abundance while rare facts get minimal space. AI, from its very first principle of mimicking human intelligence, fails to achieve this with LLMs. Humans can easily comprehend rare events, but AI cannot. To address this, researchers have started focusing compute on such events (an expensive process). Yet, as we know, the world is full of uncertainty, and it is impossible to learn every rare event from a static snapshot of the world. This leads to situations like "r in strawberry," illustrating the LLM-based state of AI.

We got the problems, but what about solutions?

Some solutions are emerging that are evolving the landscape of LLMs to attain new growth trajectories without being compute-hungry.

High-quality data can compensate for the compute of larger models. Various studies have shown that if the size of the training dataset can be reduced without impacting performance, training time decreases, meaning less compute is needed. Techniques such as model distillation, chain-of-thought reasoning, increased context length, retrieval-augmented generation, and preference training to align models with human feedback help reduce the need for heavy weights or expensive, prolonged training. These techniques demonstrate improved performance over models without them.

Architecture is a crucial part of AI research. Efforts to adapt new architectures by frontier labs can open up new paradigms of scalability. New model architectures, like Yann LeCun's world models, could be utilized, but this shift in architectural focus comes with the heavy cost of necessary research, the risk of losing market share to competitors, and requires careful experimental approaches (innovative approaches) to market these as effectively as LLMs to users.

Note: While we discussed how less compute can yield good results, it does not mean it reduces the environmental impact of AI. The carbon footprint created by AI compute is not primarily due to training (as it is a one-time and localized process) but rather from the widespread use of AI. As the number of AI users increases, its carbon footprint will also increase. This is an application-level issue, not a research-level issue.

Conclusion

Thank you for reading this blog, where I explain my understanding of the Sara Hooker's essay and the event held at Hugging Face ML Club. I aimed to simplify and align the text by adding my viewpoints. If you find any contradictions or incorrect claims in the blog, please let me know. Feedback is greatly appreciated.

Once Again Thank you !!!

Resources to refer for further reading:

Meet Super Banana 🍌

Abhinav — Sat, 13 Sep 2025 06:16:38 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

Content is king, but eye-catching visuals are the gatekeepers. For creators and e-commerce sellers, producing stunning thumbnails and professional product photos is a constant, time-consuming challenge. I built Super Banana, an AI-powered web app that acts as a creative co-pilot, drastically simplifying the creation of high-quality visuals.

Super Banana is a suite of three powerful tools:

Thumbnail Builder: Users upload their assets (like a selfie or a product image), describe their video's topic, and the AI composes a complete, click-worthy thumbnail, even generating custom backgrounds on the fly. (even this blog's cover also generated by super banana 😃)
Product Photoshoot: This tool transforms a simple product image into a professional, catalog-ready shot. Just upload a photo, describe a scene (e.g., "on a marble countertop with morning light"), and the AI creates a photorealistic image with perfect lighting and shadows.
Reimaginer: A creative playground for generating new images from text or transforming existing photos with a simple prompt, like turning a photo into a watercolor painting or a die-cut sticker.

Demo

Here's the Demo of Super Banana:

Google Cloud Deployed Version: Super Banana

How I Used Google AI Studio

Super Banana is powered by Google's state-of-the-art Gemini models, accessed via the @google/genai SDK. I strategically chose different models for different tasks to achieve the best results:

For pure text-to-image generation, like creating a background scene from scratch in the Thumbnail Builder, I used imagen-4.0-generate-001. It excels at interpreting descriptive prompts and producing high-resolution, artistic images.
For the heavy lifting and multimodal magic, I relied on gemini-2.5-flash-image-preview. This powerful model can understand and process a combination of text and multiple image inputs simultaneously. This was the key to unlocking the app's core features, allowing me to send image assets, style examples, and a text prompt all in a single API call to compose a final, cohesive visual.

My development process involved extensive prompt engineering, crafting detailed system instructions that guide the AI to act as a "world-class graphic designer" or a "professional product photographer," ensuring the output is not just technically correct but also aesthetically pleasing and commercially viable.

Multimodal Features

The true power of Super Banana lies in its deep integration of multimodal AI, which creates an experience far beyond simple image generation.

AI-Assisted Composition: The Thumbnail Builder doesn't just place images on a background; it uses gemini-2.5-flash-image-preview to understand the context of multiple assets and a text prompt. The model intelligently removes backgrounds, determines an effective layout, and blends all elements into a polished final thumbnail. This automates complex design work that would typically require manual effort in tools like Photoshop.
Contextual Image Editing: Both the Product Photoshoot and Reimaginer features leverage the model's ability to interpret an existing image and a text command. It doesn't just overlay effects; it comprehends the prompt ("add a steaming cup of coffee next to the laptop") and realistically edits the image, matching perspective, lighting, and reflections for a seamless result.
Few-Shot Style Transfer: This is my favorite feature. In the settings, users can upload "style examples"—images with an aesthetic they love. When generating a new image, these examples are sent to the model along with the prompt and assets. The AI then emulates the mood, color grading, and composition of the examples. This gives users incredible artistic control, allowing them to maintain consistent branding and generate visuals in their unique style, making the AI a true creative partner.

Conclusion

In conclusion, Super Banana successfully lowers the barrier to entry for creating high-quality visual content, making it an indispensable asset for marketers, content creators, and anyone with a story to tell visually. Super Banana isn't just about making pictures; it's about making an impact, and it delivers on that promise with remarkable fineness. Google AI Studio also plays a crucial role in bringing this idea to life. (Truly amazing...)

Thanks for reading!!

Windows' Dual-Shell Strategy and macOS's Unified Terminal Approach

Abhinav — Sun, 17 Aug 2025 04:30:47 +0000

1. Introduction

1.1. What is a CLI, Shell and Terminal ?

A Command-Line Interface (CLI) is a text-based user interface that enables users to interact with a computer program or operating system by typing commands. CLIs offer significant advantages over graphical user interfaces (GUIs), including greater resource efficiency, enhanced speed for experienced users, and the ability to automate repetitive tasks through scripting and history mechanisms. They represent the foundational method of direct text-based interaction with an operating system.

A shell is a software program that acts as an interpreter, facilitating direct communication between the user and the operating system or an application. When a user types a command into a CLI, the shell is responsible for parsing and executing that command. Shells are the logical "brains" that translate user commands into actions the operating system can perform.

A terminal emulator, conversely, is a graphical application that simulates a physical computer terminal within a modern graphical desktop environment. It provides the window or console where a shell runs, displaying text output from commands and accepting text input from the user. Terminal emulators are the visual "windows" or "containers" through which users interact with shells.

1.2. The Fundamental Role of CLIs in OS

CLIs are indispensable tools for system administrators, developers, and advanced users. They enable precise control, automation, and scripting of complex tasks that are often difficult or impossible to achieve through a graphical interface alone. Their ability to execute commands at a low level of programming provides critical access to system input and output, which is vital for diagnostics, troubleshooting, and managing system configurations.

2. Windows' Dual-Shell Strategy

Windows natively provides two primary command-line shells: Command Prompt (CMD) and PowerShell. This dual approach is not arbitrary but a deliberate strategy born from historical development, the persistent need for backward compatibility, and the drive towards modern automation capabilities.

2.1. Command Prompt (CMD)

Command Prompt (cmd.exe), often referred to as CMD, is the command-line interpreter included in the Windows NT family of operating systems. Its introduction marked a significant shift from COMMAND.COM, the shell used in the earlier MS-DOS and Windows 9x operating systems. The initial version of cmd.exe for Windows NT was developed by Therese Stowell. The underlying console host system was originally implemented as an emulation of the DOS environment, deeply integrated and cooperative with cmd.exe itself. A key design objective for CMD was to maintain general compatibility with existing MS-DOS scripts, facilitating a smoother transition for users migrating from older Windows versions.

CMD is well-suited for executing basic commands, navigating file systems, and performing quick system operations. Common examples include dir for listing directory contents, cd for changing directories, and ipconfig for network configuration details. It supports basic scripting through batch (.bat) files, enabling the automation of routine tasks such as user account management or nightly backups. CMD also offers user experience enhancements over its predecessor, COMMAND.COM, including the use of arrow keys to scroll through command history and tab completion for file and folder paths. For tasks requiring higher system access, CMD can be launched with administrative privileges, known as an "elevated command prompt," which is necessary for modifying system files or settings.

Despite its utility, CMD has inherent limitations stemming from its foundational design. Its user interface is basic, lacking modern features such as syntax highlighting or advanced tab completion capabilities found in more contemporary shells. A significant constraint is its plain text-based processing; commands accept and return only text, making complex data manipulation cumbersome as it often requires manual parsing of string output. Its scripting language is relatively rigid and basic, lacking advanced programming constructs like robust error handling, modularity, or sophisticated functions that are standard in modern scripting environments.

Furthermore, CMD lacks native, built-in support for deep system administration tasks, such as directly managing services, the Windows Registry, or Active Directory objects. Microsoft has publicly acknowledged that making significant improvements or adding new usability features to CMD is challenging without inadvertently breaking existing legacy scripts or tools, due to its deeply entrenched design and long history. This situation illustrates the "technical debt" associated with CMD's foundational architecture, rooted in the MS-DOS era and designed for text-based processing. The decision to build PowerShell from scratch was a strategic necessity to implement a fundamentally different, object-oriented design that could meet the complex demands of modern system management and automation, which CMD's legacy architecture simply could not support without radical, breaking changes.

2.2. PowerShell (pwsh)

PowerShell was developed by Microsoft as a direct response to the limitations of CMD and the growing need for a more powerful and flexible automation tool in complex IT environments. Its origins trace back to a project codenamed "Monad" (also known as Microsoft Shell or MSH), with the foundational ideas articulated in the "Monad Manifesto" by its chief architect, Jeffrey Snover, in 2002. Monad was envisioned as a new, extensible command-line interface capable of automating a wide array of core administrative tasks. After public demonstrations and beta releases, it was officially renamed Windows PowerShell in 2006.

A cornerstone of PowerShell's design is its foundation on the .NET Common Language Runtime (CLR). Crucially, unlike most traditional shells that process only text, PowerShell is designed to accept and return .NET objects. This object-based approach is its fundamental differentiator, eliminating the need to parse text output and enabling more efficient and robust data manipulation. This represents a fundamental paradigm shift in how CLI interactions are handled, moving beyond simple string manipulation to treating system data as structured objects, similar to a programming language. This object-oriented approach enables significantly more powerful and safer scripting, easier data manipulation (e.g., filtering, sorting, selecting properties without regular expressions), and deeper, more reliable integration with complex Windows APIs and services. It fundamentally changes the nature of what a shell can achieve, making it a more robust and scalable automation engine.

Administrative tasks in PowerShell are primarily performed using "cmdlets" (pronounced "command-lets"), which are specialized .NET classes implementing specific operations. These cmdlets follow a consistent Verb-Noun naming convention (e.g., Get-Process, Set-Location), making them intuitive and discoverable. PowerShell's object-based pipeline allows the output of one cmdlet (as an object) to be seamlessly piped as input to another, enabling powerful and scalable scripting by chaining commands together. PowerShell also provides a rich scripting language with support for variables, loops, conditional statements (if, foreach), modules, functions, and structured error handling (try-catch), making it highly extensible and suitable for complex automation. It features a comprehensive in-console help system, similar to Unix man pages, accessible via Get-Help and Get-Command cmdlets, offering detailed documentation, examples, and command discovery.11 PowerShell includes robust command-line history capabilities, managed by dedicated cmdlets (Get-History, Invoke-History, Add-History, Clear-History) and keyboard shortcuts (F7, F8, F9, arrow keys), with persistent history options through modules like PSReadLine.

PowerShell is the preferred tool for modern Windows environments and IT professionals, ideal for complex tasks such as managing Microsoft 365, Active Directory, various cloud services (e.g., Azure, AWS, Google Cloud), and automating enterprise workflows. It enables advanced system management, remote execution of commands and scripts, and deep integration with various IT tools and services. The PowerShell Desired State Configuration (DSC) framework allows organizations to manage their infrastructure using a "configuration as code" approach, ensuring repeatable deployments and consistent settings.

A key design feature of PowerShell is its backward compatibility; it can execute most CMD commands and batch files directly within its environment. This allows for a smoother transition for users and organizations with existing CMD-based scripts. However, the reverse is not true: the Command shell cannot execute PowerShell cmdlets. PowerShell also includes cmdlet aliases (e.g., gci for Get-ChildItem) that mimic common CMD commands, making it more user-friendly for those transitioning from CMD. Significantly, PowerShell Core (from version 6 onwards, introduced in 2016) became open-source and cross-platform, extending its reach to Linux and macOS environments.

The co-existence of CMD and PowerShell reflects Microsoft's strategic balancing act: modernization versus legacy preservation. While PowerShell is clearly the strategically favored tool for modern IT, Microsoft explicitly states that "Cmd is an absolutely vital feature of Windows and... will remain within Windows". This is further reinforced by the fact that PowerShell is replacing CMD in certain menu defaults (e.g., Win+X menu), but users can "opt out" , and older command-line switches are still supported for backward compatibility. This reveals a deliberate, pragmatic strategy: Microsoft is actively promoting and developing PowerShell as the future, while simultaneously ensuring that enterprises and users with existing, deeply integrated CMD-based scripts and workflows are not abandoned. This approach minimizes disruption and switching costs, allowing for a managed, rather than forced, transition to modern capabilities.

Key Differences: Command Prompt vs PowerShell

Attribute	Command Prompt (CMD)	PowerShell
Origin/Era	MS-DOS era (1980s)	Modern (2006)
Data Handling Paradigm	Text-based (string parsing)	Object-based (.NET objects)
Primary Scripting Mechanism	Batch files (.bat)	Cmdlets, scripts (.ps1), functions
Extensibility	Limited (relies on external executables)	Highly extensible (modules, providers)
Typical Use Cases	Basic file operations, legacy tasks, quick commands	Advanced system administration, automation, cloud management
Learning Curve	Lower for simple tasks	Steeper (due to object model)
Backward Compatibility (CMD commands in PS)	N/A (CMD cannot run PowerShell cmdlets)	Yes (can run most CMD commands)
Cross-Platform Support	Windows only	Cross-platform (since v6)
Core Design Philosophy	Backward compatibility, simplicity	Automation, extensibility, integration

Windows CLI Evolution Timeline

Year/Era	Key Event/Development	Significance
1980s	MS-DOS/COMMAND.COM	Original DOS command-line interpreter.
1995	Windows 95 Shell (GUI)	Foundation for modern Windows graphical user interface shell.
1997-1999	DBCS support in Console Host	Internationalization and character set support for console.
2002	Monad Manifesto (PowerShell Vision)	Articulation of vision for next-generation CLI.
2005	Monad Public Beta	Early public testing of new shell.
2006	Windows PowerShell 1.0 Release	Official release of modern, object-oriented shell.
2014-2016	Significant Console Host Improvements	Enhancements to underlying console window for better user experience.
2016	PowerShell Core (Open Source/Cross-Platform)	Expansion of PowerShell to non-Windows platforms.
2019-Now	Windows Terminal Introduction	Modern, tabbed, multi-shell terminal emulator.

3. macOS Terminal Environment

macOS presents a seemingly singular "Terminal" application to the user. However, this application is a sophisticated terminal emulator that provides access to a rich and powerful underlying ecosystem of Unix-like shells, rather than being a single, monolithic shell itself.

3.1. Terminal.app

Terminal.app is the default terminal emulator included in the macOS operating system by Apple. Its primary function is to provide a text-based interface for direct interaction with the operating system. Its lineage traces back to NeXTSTEP and OPENSTEP, the predecessor operating systems of macOS. This heritage is significant as it underscores macOS's deep roots in the Unix world.

Terminal.app serves as the graphical window through which users interact with various underlying Unix shells, providing a consistent visual and interactive experience regardless of the chosen shell. The application offers extensive customization options through profiles, allowing users to configure fonts, color schemes, and other visual preferences for different terminal windows. It integrates with macOS-specific features, such as the mdfind command, which provides a command-line interface to the Spotlight search functionality. Terminal.app is an essential tool for advanced users and developers, enabling tasks that lack graphical user interface tools, facilitating automation through scripting, and providing secure remote access via protocols like SSH.

Terminal.app is explicitly described as a "terminal emulator," and it allows users to "choose other shells available with macOS, such as the KornShell, tcsh, and bash", with zsh being the default. This clarifies that the terminal.app is a single graphical application that provides the window to the command line, not a singular underlying shell. This design allows macOS to offer a unified, consistent user interface (Terminal.app) while simultaneously providing choice and flexibility at the underlying shell level. This upfront distinction is critical for understanding that macOS provides a single point of access to multiple distinct shell environments.

3.2. The Rich Ecosystem of Unix Shells (zsh, Bash, etc.)

macOS is fundamentally a descendant of BSD Unix, meaning it operates on a robust Unix-like kernel and file system. This foundation inherently provides access to a mature and diverse set of standard Unix shells. Terminal.app allows users the flexibility to choose and configure their preferred shell from those available within macOS. This deep Unix heritage is not merely a historical footnote; it is a fundamental architectural advantage. Unlike Windows, which had to actively develop a new, object-oriented shell (PowerShell) to overcome the limitations of its legacy DOS-era CLI, macOS inherently benefits from decades of robust, mature, and powerful shell development already present in the Unix ecosystem (Bash, zsh, ksh, tcsh). This means Apple did not need to "invent" a new shell in the same way Microsoft did because a rich, capable set of shells was already part of its foundational operating system design. This provides macOS users with a powerful and familiar command-line environment that aligns with broader industry standards in Unix/Linux.

zsh (Z Shell): Since macOS Catalina, zsh has been the default interactive shell. It is known for its advanced features, including highly customizable tab completion, enhanced history management, and powerful scripting capabilities.

Bash (Bourne-Again Shell): A widely adopted and powerful Unix shell, Bash was the default interactive shell on macOS prior to zsh. It remains a popular choice for its extensive features and widespread use across Linux distributions.

Other Shells: macOS also includes other standard Unix shells such as KornShell (ksh) and tcsh, offering users a variety of options based on their preferences or specific scripting needs. Each shell maintains its own command history, which can be viewed, navigated, recalled, or cleared using commands like history and configurable environment variables such as HISTSIZE. The inherent capabilities of these Unix shells, such as the use of pipelines (|) to chain commands, and powerful utilities like find with the --exec option or xargs for processing command output, make them exceptionally powerful for automation and complex data manipulation.

Common Shells Available in macOS Terminal

Shell Name	Description/Key Features	Typical Use Cases
zsh (Z Shell)	Default interactive shell since macOS Catalina; Known for powerful scripting, advanced tab completion, and customizable features.	General interactive use, modern scripting, and development.
Bash (Bourne-Again Shell)	Widely used Unix shell, previously default on macOS; Robust scripting, command-line editing, and history features.	Broad compatibility, scripting on Unix/Linux systems.
KornShell (ksh)	Powerful and mature scripting language, often preferred for system administration tasks.	Complex scripting, system automation, and enterprise environments.
tcsh	C-shell like syntax, popular for interactive use among some users.	Interactive command-line sessions, users familiar with C-like syntax.

4. Comparative Analysis: Why the Divergence?

The distinct architectural and strategic choices in command-line interfaces between Windows and macOS are deeply rooted in their respective histories, core design philosophies, and target audiences. Understanding these underlying factors is key to comprehending their current states.

4.1. Historical Trajectories and Architectural Foundations

Windows: Bridging DOS/Windows 9x with NT-based Systems

Windows' CLI evolution is a narrative of continuous adaptation and backward compatibility. The transition from MS-DOS and Windows 9x (with COMMAND.COM) to the Windows NT family (with cmd.exe) necessitated a shell that could largely maintain compatibility with existing batch scripts. cmd.exe served this critical legacy purpose, ensuring a smoother migration for users and enterprises.

However, as Windows matured into a dominant enterprise operating system, the limitations of this text-based, legacy shell became apparent for complex system administration and automation. This growing need spurred the development of PowerShell, a fundamentally new, object-oriented shell designed from the ground up to meet modern IT demands. The ongoing development of the Windows Console Host and the introduction of Windows Terminal 9 further illustrate Microsoft's continuous effort to modernize the terminal emulator layer, providing a more robust and feature-rich environment capable of hosting various shells (CMD, PowerShell, WSL) without forcing a single, unified shell.
macOS: Leveraging a Robust Unix-like Core

In contrast, macOS's approach is fundamentally shaped by its Unix heritage. Originating from NeXTSTEP and OPENSTEP, which were built on a Unix foundation, macOS inherently integrated with a rich ecosystem of mature and powerful Unix shells. Apple's strategy has therefore focused on providing a single, highly capable terminal emulator (Terminal.app) that acts as a consistent gateway to these diverse and interchangeable underlying Unix shells (zsh, Bash, ksh, tcsh).4 This negated the need for Apple to develop a proprietary shell from scratch to overcome fundamental architectural limitations, as the Unix world already provided robust solutions.

4.2. Design Philosophies and Target Audiences

Microsoft's Evolution: From Basic Scripting to Enterprise Automation

Microsoft's design philosophy for its CLIs has undergone a significant evolution. Initially, CMD provided a basic command interpreter for simple tasks and backward compatibility. The strategic shift with PowerShell reflects a deliberate move towards an extensible, object-oriented automation platform tailored for the complex demands of enterprise IT administration, cloud service management, and sophisticated developer workflows. The dual-shell approach is a pragmatic recognition of the diverse needs of its vast user base, ranging from casual users running simple commands to IT professionals managing large-scale infrastructures. It represents a managed transition from legacy systems to modern environments, rather than an abrupt, disruptive change.
Apple's Approach: Providing a Powerful Unix-like Environment

Apple's design philosophy for its CLI environment is centered on offering a powerful, text-based interface for advanced users and developers that seamlessly leverages the inherent strengths of its Unix core. By integrating standard, widely-used Unix shells, macOS provides a familiar, robust, and highly capable environment for developers and system administrators who are often accustomed to working in Unix/Linux ecosystems. This approach emphasizes flexibility and adherence to established open standards rather than creating a new, proprietary shell.

Conclusion

In conclusion, Windows' dual-shell strategy, featuring both Command Prompt and PowerShell, reflects a balance between maintaining backward compatibility and advancing towards modern automation capabilities. This approach caters to a wide range of users, from those relying on legacy systems to IT professionals. On the other hand, macOS leverages its Unix heritage to provide a unified terminal emulator that offers access to a variety of powerful Unix shells. This strategy emphasizes flexibility and adherence to open standards, providing a familiar and robust environment for developers and system administrators. Both operating systems have evolved their CLI environments to meet the needs of their respective user bases, highlighting the importance of historical context and design philosophy in shaping modern computing experiences.

Algolia MCP Chat

Abhinav — Mon, 28 Jul 2025 05:52:25 +0000

This is a submission for the Algolia MCP Server Challenge

What I Built

I built algolia mcp chat, a centralized chat application that allows you to interact with and query your Algolia data using the Algolia Model Context Protocol (MCP). This app provides a conversational interface to search indices, retrieve analytics, manage index settings, and access user/application information—all powered by Algolia MCP tools and Llama using Groq.

Demo

Here's the Live Demo -> Demo

And Github Repo -> Repository

If you like the project, do give it a star 🌟.

How I Utilized the Algolia MCP Server

Algolia MCP Chat is entirely built on Algolia MCP which utilized algolia mcp for quering and managing the Algolia Data in natural language. You just need to download and keep mcp-node and just add your mcp node file path. And done, MCP Chat is ready to answer all your queries or perform operations on your algolia data in natural language. MCP Chat also shows you which MCP tool it utilized your query that help to find which tool is used for a specific query.

Key Takeaways

During the building process of Algolia MCP Chat, I faced various issues like proper configuration of algolia mcp file with our app, integrating bakend with frontend with proper formatted response of ai with MCP info and lot more.

But later on, I solved this issue using MCP documentation and formatting AI response on frontend. It uses algolia mcp which provides 33 tools by default, you can use these tools for searching, indexing, fetching info and fetching data on your algolia account.

Plus, it is entirely local, whole chat history is stored locally and only used particular info with LLM on the go. Nothing is stored anywhere (100% privacy) as through MCP, we can get some sensitive information of your account also.

You can just clone the both repo (Algolia MCP and Algolia MCP Chat) and that's it you are ready to go.

AbhinavTheDev / algolia-mcp-chat

Algolia MCP Chat

Algolia MCP Chat is a centralized chat application that allows you to interact with and query your Algolia data using the Algolia Model Context Protocol (MCP). This app provides a conversational interface to search indices, retrieve analytics, manage index settings, and access user/application information—all powered by Algolia MCP tools and LLMs.

Features

Conversational Search: Query your Algolia indices using natural language.
Analytics Insights: Get top searches, hit rates, and other analytics data.
Index Management: Access and manage index settings.
User & Application Info: Retrieve user and application details.
LLM-Powered Responses: Uses Groq Llama 3 for natural, helpful answers.
MCP Tool Integration: Leverages Algolia MCP tools for real-time data access.

Getting Started

Prerequisites

Node.js (v18+ recommended)
Git
Access to Algolia MCP Node repository

Installation

Clone this repository:

git clone https://github.com/abhinavthedev/algolia-mcp-chat.git
cd algolia-mcp-chat

Install dependencies for both backend and frontend:

cd backend
npm install
cd ../frontend
npm install

View on GitHub

Do let me know how's your experience with algolia mcp chat. If you like it, do give it a appreciation. 😇

Office Table - CSS ART Edition

Abhinav — Wed, 23 Jul 2025 01:39:36 +0000

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, CSS Art: Office Culture.

Inspiration

I want to build a office table that includes everything which helps me to keep motivated and gives a energetic vibes. Also, it must have all essentials (rule of essentialism). Therefore, I created this ART with headphones (music is necessary for my focus) and Coffee Cup (Developers basic need).

Demo

You can also checkout the live link of ART: Live Demo

Journey

For building this ART my goal is decided, I want to have all the things that i could imagine for my desk.

I started by creating Desk Component Art which includes Desk Container, Desk Art and Imac monitor component (my fav one). Alongwith a Ergonomic Chair Component (my back needs).

But for adding other component i explored various other Pens of community that help me to make the Art more like my imagination. Pen I used for Headphone Component -> CodePen by Andrea and Flower Pot Component -> CodePen by Suzanne Aitchison.

Then added all these component on my table which gives fresh vibes and minimal look. Cup Component is also created which contains my coffee (for energy of a developer). Then a TODO board, I easily forget things, Therefore, a TODO board is also required to keep me focused towards my work.

Now, my table had everything which i needed (headphones for listening music, coffee for fuel of dev, flower pot for fresh vibe, TODO board for focus towards work) that helps me to keep motivated and energetic in my office. :)

If you like the art, do give a star 🌟 to Repo:

AbhinavTheDev / Office-Art

CSS Office Art

An office desk art created with HTML and CSS.

Built with

Credits

headphone: CodePen by Andrea
Flower Pot: CodePen by Suzanne Aitchison
GitHub Badge: add-github-badge by ArnavK-09
Images: Google

View on GitHub

I hope you like my ART, and do let me know what do you think about it. Love to know....

How Generative AI is Being Used in New Ways

Abhinav — Mon, 21 Jul 2025 00:30:53 +0000

Introduction

Hello everyone!
Today, I am going to share with you all what I recently found and how good it is.
Recently, I came to know about an Asset Management Platform that helps developers like us to manage assets on the web efficiently. Yes! I am talking about Cloudinary (an Image and Video API Platform). It provides dynamic APIs to manipulate assets like images and videos on the web.

But today, I am not going to share what Cloudinary is; instead, we are going to explore some new and exciting features from Cloudinary.

Quick Intro of Cloudinary

A quick introduction to Cloudinary for those who haven't heard this name before, so you can understand the blog better. If you already know what it is and have used it, you can skip this section.

Cloudinary is an Image and Video API Platform that offers dynamic APIs to host your assets on the web with good support and accessibility. Along with APIs, it also offers an Asset Management service where you can store, host, and manipulate your assets. This is how Cloudinary provides a full set of features that a developer or organization needs to ensure their service does not face high load or compromise the quality of assets for performance.

Now that you have a solid context of what Cloudinary is, let's move ahead…

Why am I writing this blog?

Now, you are wondering why I am writing this. Is this a Cloudinary doc or advertisement? No, it's not. I am writing this to share an experience with you all that excites me a lot.

Recently, I got a newsletter email from the Cloudinary team (they called it Cloudinary Developer Bytes) and I opened it. In that email, the Cloudinary team shared what new and cool things they are shipping and building. It includes various things from MCP Server to 3D Spinset to tutorials and a lot more. By going through this, I found that Cloudinary is also shipping new AI features on its platform. Honestly, at first, I thought it was some chatbots or agents to transform images or videos. But I was wrong; they really shipped some nice and cool AI features that can enhance the way we interact with assets on the web.

Here's the list of AI features for images available so far as I write this article:

You can now use Cloudinary to perform many operations on your assets directly on the web.

Exploring Cloudinary's AI Features

I tried some of these features (like Upscale, Generative Remove, Generative Replace) and I really love them:

Here are some examples:

Low Resolution Cat Image This cat image has dimensions of 340 × 400. By simply adding e_upscale/ in the URL, the image is upscaled to 1360 × 1600, almost 4 times larger. You can do this on the web by just modifying the URL parameters to upscale your image 4 times.

You can easily test it by adding those parameters between the upload and version number (Modified URL with those parameters). That's it, your image is upscaled. No website, no subscription, no tools needed.

I also tried Generative Background Replace, which lets you change the background of any image to anything you want. For example, here is an image of a girl and a dog with a solid background → Image. By adding e_gen_background_replace:prompt_times%20square in the URL parameters, it gets a Times Square background → Transformed Image.

You can also combine these effects as needed (peak customization), for example, transforming both the background and objects → Modified Image.

There are many more features available for you to explore and enjoy. And this is just for images; Cloudinary also offers various AI features for video manipulation. Check out these docs: AI In Action

How can you do this or create your own…

I faced some issues with this because it wasn't clearly available in the docs, or I couldn't find it (skill issues). However, it's not too difficult to locate. To test AI features or create your own:

Go to your Cloudinary console → Go to the image section → Go to Manage Transformations (here you will find all your saved transformations with your custom names (yes! that’s also possible)) → Then click on the + icon, and you will be redirected to the transformations console, as seen in the second image.

The Transformation Console Page:

As shown in the image, you have sample images and options to test features with images in the console. You can find the URL parameters for that feature in the URL section (you also get SDK code to use in your application). After testing, you can save your custom actions with your custom parameter name, as seen in the first image (t_abhinav).

Conclusion

I hope you find this article helpful and learn something new. If you have already used or tested these Cloudinary's features, please share your experience. Did you like it, or did you encounter any issues?

Do you know of any other tools or platforms that offer similar features? Please let me know, as I would be happy to test or use them.

Thanks for reading!

Goodbye :) See you in the next article 👋

Meet Potion: Your Smart Note-Taking Companion

Abhinav — Mon, 30 Jun 2025 02:49:16 +0000

Hello Everyone,

In this article, we are going to know how i built my latest project Potion with MindsDB, And how it made it super easy to build the advanced AI integrated project from both user and developer side. (Yes! it is)

First of all, What is MindsDB?

Before going deeper into other details, let's first understand what MindsDB is and how it made it super easy to build the workflow and execute it. MindsDB is an AI Data Solution Platform that makes it easy to connect, unify, and respond (as stated on their site). Simply put, we can understand MindsDB as an abstraction (Hidden Layer) that handles the connection of various data sources and automatically creates pipelines from that data, so you don't need to worry about AI integration development. MindsDB made it easy, like plug and play. Now, you can focus more on business logic rather than other unnecessary stuff like building a chatbot that answers user queries (sadly, but it's the truth!).

Core Principle of MindsDB

seamless integration, organization, and utilization of data (same thing we understand above :))

But how MindsDB able to bring all these features...What's the secret?

SQL is the secret (Yes!). MindsDB is using SQL-based syntax as its core interface for AI and machine learning operations. By enhancing standard SQL with AI-specific extensions, MindsDB makes artificial intelligence accessible through a familiar database query language. This approach democratizes AI, allowing developers and data professionals to use their existing SQL skills for machine learning tasks, thus removing traditional barriers to AI adoption.

This approach not only simplifies the integration process but also ensures that AI capabilities are seamlessly incorporated into existing workflows with minimal effort. As we all know, SQL has historically transformed database querying, saving billions for companies worldwide. Now, MindsDB is harnessing that power to drive their advanced AI innovation, making complex integrations more efficient and accessible.

During the development of Potion, I realized why this is crucial for developers and how it greatly impacts the development cycle, making a developer's work much easier and more efficient.

What is Potion, through which I learned all of this?

Potion is an Intelligent Note-Taking Assistant that stores your daily notes or moments in your local storage (yes! no database, 100% privacy) and your local MindsDB instances or image if you are using Docker :). But this is a simple note application—what's intelligent about it? Wait, Potion not only stores your notes, it can search your notes (not just a keyword matching search), it's an AI Semantic Search. You have an AI Agent running only for you and with your data locally (Yes! No more clouds and data privacy issues). The story doesn't end there; you also get an AI summarization feature that can summarize your notes into a much more concise form (Yes! No more juggling). Sounds cool, doesn't it?

All of these features are too complex, and generally, it takes me months to implement all of this in a single application. But can you believe, I shipped all of these features in a week (yes! working week). And it stretched to a week because I got some logic errors; otherwise, you can ship all of these features in your applications in less than a week. (yes! it is true, no bluffs). Thanks to MindsDB for bringing such a platform that can help you ship industry-level features within a span of a day.

Some of the key features that i like in MindsDB?

MindsDB and their platform are loaded with so many cool features, you can check out later by installing it locally, but the features that I like the most are:

Knowledge Base: Kb is one of the finest and best features of MindsDB. Using Knowledge Base, you can transform your raw data into vector embeddings that can help you build various applications based on it, like RAG, Text Summarization, and much more. And for all of this, you do not need complex implementations, integrations of Vector DB, Embedding Models, or other stuff that can make you mad. But with MindsDB, you just need these code snippets and that’s it! Now add your data and build your application. (Yes! it is that simple)
```
CREATE KNOWLEDGE_BASE my_kb
USING
   embedding_model = {
       "provider": "openai",
       "model_name" : "text-embedding-3-large",
       "api_key": "sk-abc123"
   },
   reranking_model = {
       "provider": "openai",
       "model_name": "gpt-4o",
       "api_key": "sk-abc123"
   },
   metadata_columns = ['product'],
   content_columns = ['notes'],
   id_column = 'order_id';
```
Agent: Earlier, when we needed to add an AI Agent or build an AI Agent, we first had to create a workflow for it and implement it. If we wanted it to be based on our data, we either needed to fine-tune that LLM model (which is too costly) or build an efficient pipeline that could handle such specific tasks (not an easy job). Both of these options are too hectic and costly, plus it is not guaranteed that your Agent will work perfectly unless you do extensive testing (again, a hectic and costly process).
But MindsDB brings a solution to eliminate this problem, which is the MindsDB Agent. MindsDB’s Agents are industry-level conversational agents that can answer questions using your data with higher accuracy. To use a MindsDB Agent, you do not need high-level functions or implementations. With a simple query, you can deploy an industry-level Agent.

CREATE AGENT my_agent
USING
   model = 'gemini-2.0-flash',
   google_api_key = 'xyz123',
   include_knowledge_bases= ['mindsdb.sales_kb', 'mindsdb.orders_kb'],
   include_tables=['postgres_conn.customers', 'mysql_conn.products'],
   prompt_template='
       mindsdb.sales_kb stores sales analytics data
       mindsdb.orders_kb stores order data
       postgres_conn.customers stores customers data
       mysql_conn.products stores products data
   ';

There are many more exciting features available in MindsDB, like Models, AI Tables, Views, Jobs, and much more. If you are thinking of adding AI power to your application, then do check out MindsDB; you will be glad you did. Yes!

Now, let’s come to potion again..

Potion is a fully open-source web application, and all the code is available in the GitHub repo. Do check it out if you want to explore MindsDB. But keep in mind, you should have MindsDB installed locally first to use all the core AI features of Potion. For details, you can check out these guides.

Here’s the Repo: Potion’s GitHub Repo

Please give it a star ⭐ if you like the project. It really boosts my energy to create more applications like this for all of you.

If you don’t have time to install and try everything, no worries! We also have a Demo Video that shows you a glimpse of all the awesome MindsDB integrations in Potion. However, not everything can be covered in a demo. Therefore, checking out the codebase will surely give you an extra edge. (And we are developers, we can read codebases.)

Here’s the Demo: Potion’s Demo Video

I don’t need to say this, but still, if you like the demo, please like the video. If you don’t like the video, you can also dislike it and tell me in the comments what I can improve in my demos.

Thank You!

If you reached this point, I want to thank you. Thanks for reading this blog. I hope you found something new in this article that can help you in some way. If you have used MindsDB, please let me know about your experience. And if not, try it first and then tell me how much you like it. ;)

Good Bye!!

Access and Refresh Token Explained

Abhinav — Sun, 15 Jun 2025 17:12:54 +0000

While building an application or authentication system, it's crucial to ensure that users have access only to the data they are authorized to view, and each access must be granted to verified users only. Unauthorized access to your data can raise concerns about your application's workflow and authenticity. OAuth 2.0 and OpenID Connect are two protocols that introduce security measures and token-based authentication for applications, adding a security layer to your application. These measures help make accessing your application data a secure and authentic process. The tokens used for this process are Access Tokens and Refresh Tokens.

Access Token

An access token is a short-lived token used to access data in your application. Whenever a user requests data, this token is verified for accessing the data. Generally, it is stored in-memory (not in LocalStorage or a database) to enhance security. The lifespan of an access token is typically a few minutes or seconds. This short lifespan minimizes the risk of misuse if the token is compromised.

Access Tokens are typically added to API request headers as authHeader, and this value is shown as Bearer -accessToken-. This is the standard method for using Access Tokens in applications and for making requests with an Access Token.

Here are the functions where we implemented the generation and verification of Access Tokens in JavaScript.

// generateToken function to generate Access Token in your NodeJS Application
const generateAccessToken = (user) => {
  return jwt.sign(
    { id: user.id, email: user.email }, // payload
    process.env.JWT_SECRET,
    { expiresIn: process.env.JWT_EXPIRES_IN } // generally 5min or 60 sec
  );
};

// function to verify your access token and give access to you in application
const verifyToken = (req, res, next) => {
  const authHeader = req.headers.authorization;

  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ message: 'Access token missing or invalid' });
  }

  const token = authHeader.split(' ')[1];

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (err) {
    return res.status(401).json({ message: 'Invalid or expired token' });
  }
};

As you can see, the Access Token is generated with payloads, verified, and then grants the user access to the next process they requested.

Refresh Token

A refresh token is a long-lived token used to generate new access tokens after the expiration of an access token. It is stored securely in a database and user storage. After the access token expires, the application verifies the refresh token against the database. Upon successful verification, new access and refresh tokens are generated, providing the user with continued access to the requested data.

Here are the functions to generate and verify a refresh token.

// function to generate Refresh Token
const generateRefreshToken = (user) => {
  return jwt.sign(
    { id: user.id },
    process.env.JWT_REFRESH_SECRET,
    { expiresIn: process.env.JWT_REFRESH_EXPIRES_IN } // generally 7d
  );
};

// function to verify refresh token and generate new Access Token
function verifyRefreshToken() {
  try {
    const decoded = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET);
    const newAccessToken = generateAccessToken({ id: decoded.id, email: decoded.email });
    res.json({ accessToken: newAccessToken });
  } catch (err) {
    return res.status(403).json({ message: 'Refresh token expired or invalid' });
  }
});

In the code snippet, you can see that the refresh token is created with minimal information, like the ID, because it's only needed to verify the user, not to access resources. During verification, the refresh token is checked, and after successful verification, a new access token is generated to provide the user with access to the resource.

Key Aspects of Access and Refresh Token

The key aspect of the separation between access and refresh tokens lies in the possibility of making access tokens easy to validate. An access token that carries a signature (such as a signed JWT) may be validated by the resource server on its own, without needing to contact the authorization server.

Refresh tokens, on the other hand, require access to the authorization server. By keeping validation separate from queries to the authorization server, better latency and less complex access patterns are possible.

Appropriate security in case of token leaks is achieved by making access tokens as short-lived as possible and embedding additional checks (such as client checks) into them. Refresh tokens, by virtue of being long-lived, must be protected from leaks. In the event of a leak, blacklisting may be necessary in the server (short-lived access tokens force refresh tokens to be used eventually, thus protecting the resource after it gets blacklisted and all access tokens are expired).

Conclusion

In conclusion, implementing access and refresh tokens is a fundamental aspect of securing your application's data access processes. By understanding the distinct roles and lifespans of these tokens, developers can ensure that only authorized users gain access to sensitive information, thereby maintaining the integrity and security of the application. The strategic use of short-lived access tokens and long-lived refresh tokens, along with robust validation mechanisms, helps mitigate risks associated with token leaks and unauthorized access.

As a result, these practices not only enhance security but also improve the overall user experience by providing seamless and secure access to application resources.

Building Rock Paper Scissors Game with AI 💥by Amazon Q

Abhinav — Thu, 08 May 2025 11:31:24 +0000

This is a submission for the Amazon Q Developer "Quack The Code" Challenge: That's Entertainment!

Rock Paper Scissors is one of my favorite games, which I used to play a lot. This week, I am thinking of experiencing that joy again using AI, but I am not sure how to bring it into existence. As I am not familiar with any related technology that could allow me to build it, I then got to know about Amazon Q Developer and its strengths in writing code and implementing logic.

Therefore, this article details my experience of using Amazon Q Developer and how it allows me to build a complex (yes! you heard right!), webcam-controlled Rock Paper Scissors (RPS) game, demonstrating how Q significantly reduced my development barriers and delivered awesome results 😍.

Like this:

What I Built

Basically my goal was to create a fully interactive, browser-based Rock Paper Scissors game with two distinct player types: Human and AI.

Human Player (Me): Input is captured via the user's webcam, with hand gestures (Rock, Paper, or Scissors) being recognized in real-time.
AI Opponent: The AI's moves are determined by Gemini, accessed via its API, adding an intelligent and unpredictable element to the gameplay.

The entire application implemented so simply in vanilla JavaScript for logic and interactivity (so that i can understand better).

Demo

You can also checkout the demo -> Demo

Code Repository

Here is the Source Code of project -> Github Repo

If you like the project then do give it a star ⭐.

How I Used Amazon Q Developer

Amazon Q Developer played a key role in bringing my game idea to life. It helped me with the entire process, from structuring the project to implementing the code. Since I didn't have a detailed plan for this project, I entered this high-level prompt into Amazon Q:
Create a complete, functional, browser-based Rock, Paper, Scissors (RPS) game in JavaScript, HTML, and CSS. The game will feature a human player whose moves are detected via webcam and an AI opponent whose moves are determined by the Gemini LLM via its API.

Instantly, it provided a clear plan and began building the project. My initial thought was that it might not get it right on the first try, and I'd need to guide it through several iterations to get a working prototype. I was surprised to be wrong because Amazon Q delivered a solid implementation that handled everything smoothly – from error handling to integrating the necessary libraries, it all worked perfectly from the start.

I must say, Amazon Q Developer is an excellent AI Coding Assistant. It increased my productivity and helped me bring ideas to life much faster and with fewer errors. I've also used other AI coding assistants and builder tools before, but none have provided me results of this level.

If you haven't explored Amazon Q Developer yet, I highly recommend giving it a try – it would be a nice experience for your workflow. For those who have already used it, I'd love to hear about your experiences in the comments below!

You can also checkout the Amazon Q and use it for free: Amazon Q Developer

Thanks for Reading and Stay Tuned for more such stuffs!

AI: The Research Companion

Abhinav — Sun, 13 Apr 2025 13:32:08 +0000

Introduction

Artificial Intelligence (AI) and Large Language Models (LLMs) are fundamentally reshaping scientific research. These technologies are going beyond text to include multimedia capabilities and are transforming how complex tasks are approached across disciplines—from medicine to materials science. By automating everyday tasks, accelerating discoveries, and allowing researchers to solve complex problems more efficiently.

Increasing Research Efficiency

AI can increase research efficiency by automating various tasks such as data analysis, hypothesis testing, and literature review which require lot of time and effort of researchers. For example, the concept of an "autonomous generalist scientist" (AGS)—a system combining AI and robotics to manage the entire research process—promises significant reductions in time and resource requirements. Various Studies in various disciplines indicates that AI automates over half of researchers workload, freeing researchers to focus on evaluating AI-suggested innovations and strategic decisions. In data-intensive fields like genomics and climate science, AI-powered platforms rapidly analyze massive datasets, revealing patterns and insights beyond human capability.

Agentic Research Evolution

AI Agents can help to bring these advance technologies in the current research landscape with much greater efficiency and less complexities for researchers. These agents can:

Automate routine tasks, freeing researchers for creative and complex work
Analyze data with high precision, reducing human errors
Provide comprehensive insights for informed decision-making
Explore vast problem spaces to identify novel solutions
Facilitate interdisciplinary collaboration

One of the example of such type of agent is Research Agent, an open-source web application designed to assist researchers by automating and optimizing various aspects of the research process. It leverages AI technologies like LLMs, Web Search and Indexing to streamline tasks such as creating research plans, conducting literature reviews, and performing data analysis. This allow users to generate comprehensive research on diverse topics with a single click.

How Research Agent Works

The Research Agent uses the LangGraph research assistant framework to structure its workflow. This framework ensures efficient data fetching, analysis, and synthesis into final research outputs. The architecture consists of nodes and edges designed for proper data handling and effective response generation. For generating and summarizing findings, the system uses LLM models, which are well-suited for this workflow. To enhance web search capabilities, various search APIs are integrated, enabling the agent to retrieve real-time content without getting blocked, thus making the research process more efficient and up-to-date.

If you like the project then

Do give a star ⭐ Do Upvote It

It means a lot for me.

AI as a Copilot, Not as Pilot

While AI’s role in research is amazing and helpful, but experts also agreed that AI should help the professionals instead of replacing them. It is also proved that AI lacks creativity, critical thinking, and holistic understanding which are inherited in humans. Frameworks like LangChain and many more AI related frameworks considered such limitations of AI therefore these frameworks introduced Human-In-Loop(HIL) mechanism which allow such technologies to provide more creative and better responses. Still such technologies are not able to fully substitute human researchers and they can't be, suggesting a future where AI acts as a powerful assistant rather than a standalone scientist. (Yup! we are safe...)

Conclusion

AI Agents can revolutionize research landscape by enhancing productivity. Its ability to automate tasks and analyze vast datasets is reshaping how science is conducted. Practical tools such as Research Agent demonstrate how AI can streamline research workflows and provide comprehensive researches. However, realizing AI’s full benefits requires careful attention to ethical standards, human-in-loop, and sustainable integration. Balancing innovation with responsibility will be key to advancing knowledge while preserving human integrity in this ongoing tech revolution.