Coder Legion - Recent posts tagged genai

From Career Confusion to Career Clarity: Building Supernova AI with Google Gemini

Tue, 15 Sep 2026 11:30:24 +0000

What should I pursue after graduation? Which skills should I learn? Which certifications are actually relevant? And where do I even begin?

These questions are common not only among students but also among professionals trying to grow, upskill, or transition into new career paths.

Today, learning opportunities are everywhere. There are thousands of online courses, certifications, career roadmaps, job roles, and emerging technologies to explore. Yet having access to more information does not always make career decisions easier. In many cases, it creates even more confusion.

A student may know that artificial intelligence, cloud computing, data analytics, cybersecurity, or product management are growing fields—but may not know which path aligns with their interests and abilities. Similarly, a working professional may want to upskill but struggle to understand which certification would genuinely support their career goals.

The challenge is often not a lack of talent or ambition.

It is a lack of personalized direction.

This challenge inspired me to build Supernova AI, an AI-powered Career Decision Intelligence Platform developed as my capstone project during the Google Cloud Gen AI Academy APAC 2026.

The Story Behind Supernova AI

Growing up, I had limited exposure to the wide range of career opportunities that existed beyond conventional paths. Like many students, career decisions were often shaped by what was familiar, socially accepted, or commonly recommended rather than by a deeper understanding of individual interests, strengths, and aspirations.

Over time, I realized that this experience was not unique.

Many students—particularly those from smaller cities and underserved communities—may have the ability and ambition to succeed but lack access to personalized career guidance. They may not know about emerging roles, the skills those roles require, the certifications that can support their growth, or the practical steps needed to move from interest to opportunity.

This led me to ask:

What if career guidance could begin with the individual rather than a generic list of popular careers?

That question became the foundation of Supernova AI.

What Is Supernova AI?

Supernova AI is an AI-powered career guidance platform designed to help students and young professionals make more informed and confident career decisions.

Instead of relying only on static questionnaires or offering the same recommendations to every user, the platform considers an individual’s:

Educational background
Interests
Existing skills
Career aspirations
Preferred areas of growth

Using this information, Supernova AI generates a personalized AI Career Report that provides not only a career recommendation but also actionable guidance to help the user move forward.

The report includes:

A personalized Career Match Score
A recommended career path
An explanation of why the career aligns with the user’s profile
Skills the user should develop
A structured learning roadmap
Relevant certification suggestions

The goal is not to let AI make career decisions on behalf of people. Instead, Supernova AI acts as a decision-support system—helping users discover possibilities, understand their options, identify skill gaps, and take informed next steps.

Demo: https://youtu.be/-UWCe7B7waE?si=GGAwWbFWtz3kg5tT

How Supernova AI Works

The platform follows a simple and accessible workflow.

First, the user enters information about their education, interests, skills, and career goals through a profile form.

The frontend securely sends this information to an Express.js backend, which communicates with Google’s Gemini 2.5 Flash model. Gemini analyzes the user’s profile and generates contextual career recommendations.

The structured response is then displayed as a personalized AI Career Report within seconds.

The complete workflow is:

User Profile → Secure Backend Processing → Gemini 2.5 Flash Analysis → Personalized Career Report → Actionable Career Roadmap

This transforms basic user information into practical career intelligence that can help users understand not only what they could pursue, but also why the path may suit them and how they can begin preparing for it.

Why Google Gemini 2.5 Flash?

For Supernova AI, I wanted an AI model capable of understanding multiple aspects of a user’s profile together rather than evaluating each input independently.

A person’s career direction cannot be determined by one skill, one academic qualification, or one interest. Meaningful guidance requires context.

Google’s Gemini 2.5 Flash enables the platform to analyze the relationship between a user’s education, interests, skills, and aspirations and generate a structured, personalized response in real time.

The solution was developed using:

HTML5 for the frontend structure
CSS3 for a clean and responsive interface
JavaScript for client-side interactions, API requests, and dynamic content rendering
Node.js as the backend runtime
Express.js for REST API communication
Google Gemini 2.5 Flash API for career analysis, recommendations, skill guidance, learning roadmaps, and certification suggestions

The architecture was intentionally designed to be lightweight, accessible, and cost-effective while providing a scalable foundation for future deployment through Google Cloud Run and integration with additional cloud services.

What Makes Supernova AI Different?

Many conventional career platforms rely on fixed questionnaires, predefined career categories, or generic recommendations.

Supernova AI focuses on contextual personalization.

It does not simply suggest a career title. It aims to answer the questions that often come immediately afterward:

Why could this career be suitable for me?

Which skills am I currently missing?

What should I learn first?

Which certifications could support my development?

What practical steps can I take to move toward this career?

By bringing these insights together in one personalized report, Supernova AI helps turn career exploration into an actionable learning journey.

Its key features include:

AI-powered career recommendations
Personalized Career Match Scores
Contextual explanations for recommended career paths
Skill-development recommendations
Individual learning roadmaps
Industry-relevant certification suggestions
Fast and interactive career guidance
A clean and accessible web experience
A scalable Node.js and Express.js backend

Building for Accessibility and Equal Opportunity

One of the core motivations behind Supernova AI is the belief that access to career guidance should not depend entirely on a student’s location, background, institution, or professional network.

Students from smaller cities and underserved communities may have fewer opportunities to interact with career counsellors, industry professionals, or mentors working in emerging fields. This can influence the careers they consider—not because they lack potential, but because they may not have enough exposure to available opportunities.

Supernova AI aims to help bridge this awareness gap by making personalized guidance more accessible.

The platform is not intended to replace teachers, mentors, career counsellors, or human judgment. Instead, it can complement them by helping users begin with greater clarity, ask more informed questions, and better understand the skills and learning opportunities relevant to their goals.

From Learning About Gen AI to Building with It

Developing Supernova AI taught me that building with generative AI involves much more than connecting an application to a model.

It begins with understanding a real problem.

It requires thinking about the user, identifying what information is genuinely useful, designing meaningful prompts, structuring AI-generated outputs, and ensuring that recommendations are clear and actionable.

Through this project, I had the opportunity to move beyond learning about generative AI and apply it to a challenge that has personally resonated with me.

The experience also strengthened my understanding of how AI can be used not merely to generate information, but to support better decisions.

Looking Ahead

Supernova AI currently provides a functional foundation for personalized AI-powered career guidance, with opportunities for further development.

Future enhancements could include:

Resume-based skill analysis
Personalized skill-gap assessments
Dynamic learning pathways
Career progress tracking
Integration with verified learning and certification platforms
Labour-market and emerging-job insights
Mentor and career-counsellor collaboration
Multilingual career guidance
Accessibility-focused features
Integration with career and industry datasets through Google Cloud services

These capabilities could make career guidance more inclusive, adaptive, and responsive to changing industry needs.

Every Career Journey Deserves a Clearer Starting Point

Supernova AI began with a simple observation: many people are willing to learn and grow but are uncertain about where to begin.

Students may have talent but limited exposure.

Professionals may have experience but lack clarity about their next step.

Learners may have access to hundreds of certifications but not know which ones align with their goals.

Supernova AI aims to bring these disconnected questions together and transform them into personalized, actionable guidance.

For me, Supernova AI is more than a career recommendation platform. It represents the possibility of using generative AI to make career exploration more personalized, accessible, and inclusive—helping learners move from uncertainty to informed action, one meaningful step at a time.

From 4,000+ Applications to 250 Builders: Building a Multi-Agent Video Pipeline at the Google DeepMind Bangalore Hackathon

Wed, 19 Aug 2026 06:27:37 +0000

TL;DR

Got selected out of 4,000+ applicants for the Google DeepMind Bangalore Hackathon 2026 (250 builders made it in). My teammate and I merged two hackathon tracks — Conversational Video & Motion with Omni Flash and Local-First Agents with Gemma 4 — into one pipeline: a multi-turn conversational video orchestration agent that asks clarifying questions and iteratively refines its output, backed by on-device reasoning for state management. No trophy this time, but a working prototype and a lot of lessons. Here's the build.

The selection

Google DeepMind and Cerebral Valley ran this hackathon in Bangalore, and the numbers alone made it feel different from the college-circuit events I'd been doing: 4,000+ applications, 250 seats. Getting the acceptance email didn't fully register until I was actually in the room — this wasn't a campus event anymore, it was a room full of people who build for a living.

The idea: merging two tracks instead of picking one

The hackathon offered several tracks. Two stood out to me and Rohan:

Conversational Video & Motion with Omni Flash — generate and iterate on video through natural conversation
Local-First Agents with Gemma 4 — on-device reasoning and autonomous decision-making

Instead of choosing one, we asked: what if the video generation system was the agent? So we built a pipeline where:

Gemini Omni Flash + NB2 Lite handle multi-turn conversational video orchestration — the system doesn't just take a prompt and spit out a video. It asks clarifying questions, holds context across turns, and iteratively refines the output based on what the user actually meant.
Gemma 4 runs on-device for state management and decision-making — tracking where the conversation is, what's already been generated, what still needs clarifying, and deciding the next action locally instead of round-tripping everything through a heavier model.

The result was an agent that blends reasoning, local intelligence, and multimodal generation into a single loop, rather than three separate systems bolted together.

What building under a deadline like this actually felt like

Tight deadlines are a hackathon constant, but the density of the room changes the pressure. Every table around us was shipping something legitimately interesting, which is equal parts motivating and intimidating. Having a partner who's good at both brainstorming and debugging (thanks, Rohan) mattered more here than in any hackathon I'd done before — there wasn't time to context-switch between "figuring out the architecture" and "fixing why the state manager is out of sync."

The outcome

We didn't place. No trophy this round. But we left with:

A working end-to-end prototype of the conversational video + local agent pipeline
Direct exposure to how a team like DeepMind's frames the "agentic + multimodal" problem space
Genuinely useful conversations with other builders working on adjacent problems
Insights from Amit Vadi and Ray Del Vecchio, who spoke at the event

Why I'm writing this up

Hackathons are noisy — you build for 24-48 hours, present, and the artifact usually dies in a GitHub repo somewhere. Writing it up is partly documentation for myself (what worked, what I'd do differently) and partly a way of tracking how the kind of problems I'm choosing to work on has shifted — from single-model chatbots to multi-agent, multimodal, local-first systems.

If you're building anything similar — conversational video generation, on-device agent state management, or just curious about how Omni Flash and Gemma 4 play together — I'd genuinely like to compare notes. Drop a comment or find me on GitHub.

This is part of an ongoing hackathon log — you can find the earlier entries (including two first-place wins and a near-miss with a legal-aid kiosk built on a multi-agent swarm) on my blog.

Are we hiring developers who can build, or developers who can prompt?

Wed, 29 Jul 2026 10:46:09 +0000

I recently interviewed some fresh graduates and noticed an interesting pattern.

The projects on their resumes looked impressive:

Beautiful UI
Modern tech stacks
AI-powered features
Clean GitHub repositories

At first glance, they looked like strong candidates.

But when we started discussing their projects:

Why did you choose this architecture?
How does this API work?
What challenges did you face?
How would you scale this?
What happens if this component fails?

Many struggled to explain their own work.

This made me think:

AI has lowered the barrier to building software, which is great.

But are we changing how we evaluate developers?

Maybe a project demo is no longer enough.

The real evaluation should focus on:

Understanding of fundamentals
Problem-solving approach
Ability to explain decisions
Debugging skills
Ownership of the work

AI will help developers build faster, but understanding what they are building and why still matters.

Curious to hear from hiring managers and developers:

How are you evaluating fresh graduates in the AI era?

English is The Worst Programming Language

Sun, 26 Apr 2026 03:52:16 +0000

In the world of software engineering, we obsess over programming languages: their syntax, their type systems, their performance characteristics, their paradigms. We debate Rust versus Go, Python's readability versus C++'s control, Haskell's purity versus JavaScript's chaos. Yet we rarely acknowledge the elephant in the room — or rather, the language we all use every day that makes every other language look like a model of crystalline precision: English.

English is, without question, the worst programming language ever created. It is not merely flawed; it is fundamentally unsuited for the reliable transmission of complex ideas. Anyone who has ever tried to communicate a non-trivial technical concept to another human being knows this instinctively. The ambiguities, the contextual dependencies, the endless opportunities for misinterpretation — English excels at all of them.

If you have spent any time in meetings, code reviews, specification documents, or even casual Slack threads, you have felt the pain. And if you have any background in mathematics, physics, or formal logic, the contrast becomes almost comically stark.

Precision: The Foundation of Reliable Computation (and Communication)

At its core, a good programming language is a formal system designed for unambiguous execution. Every valid program has exactly one meaning under the language's semantics. A compiler or interpreter will produce the same behavior every time, assuming the same inputs and environment. This is not an accident; it is the entire point.

Mathematics and physics adopted formal languages for the same reason. When Newton or Leibniz developed calculus, they didn't just wave their hands and say "the rate of change, you know, kinda like speed but for curves." They created notation — symbols, rules of manipulation, axioms — that allowed precise statements like:

This expression has one, and only one, interpretation among those who understand the formal system. There is no room for "well, depending on what you mean by derivative" or "in my experience, sometimes it's 2x plus or minus a bit."

Physics follows suit. Maxwell's equations in differential form are not poetic suggestions:

These are not open to "opinions-based" interpretation. Misunderstand a sign or a vector component, and your electromagnetic device will quite literally fail to function. Engineers and physicists spend years learning to think within these formalisms precisely because natural language is too sloppy for the phenomena they describe.

Formal languages exist because human natural languages are terrible at edge cases, scope, and unintended interpretations. We invented predicate logic, set theory, lambda calculus, and programming languages to escape the swamp of ambiguity.

English, by contrast, is the swamp.

The Many Ways English Fails as a Specification Language

Consider something as seemingly simple as a requirement: "The system shall process transactions quickly."

What does "quickly" mean? Under 100ms? Under 500ms? Does it depend on load? On hardware? On network conditions? Is this a hard guarantee or a soft target? English offers no mechanism to distinguish these.

Now imagine trying to implement a sorting algorithm based on an English description:

"Sort the list in ascending order, but put the most important items first, unless they're duplicates, in which case keep the original order for those."

Good luck. Is "important" defined? What constitutes a duplicate? Does "original order" refer to stable sort semantics? English leaves all of this to intuition, shared context, and — inevitably — arguments in code review.

Real-world examples abound in software projects:

"Handle errors gracefully" — Does this mean log them? Retry? Notify the user? Crash the process? Return a default value?
"Make the UI intuitive" — Intuitive to whom? A power user? A complete novice? Someone from a different cultural background?
"The cache should be consistent" — Eventual consistency? Strong consistency? What about partition tolerance?

These are not edge cases. They are the norm. Experienced engineers learn to translate vague English requirements into precise specifications, often using formal tools (user stories with acceptance criteria, UML, TLA+, property-based testing) precisely because English alone is insufficient.

Ambiguity at Every Level

English is ambiguous at the lexical, syntactic, semantic, and pragmatic levels.

Lexical ambiguity (multiple meanings for the same word): "Bank" can mean a financial institution, the side of a river, or to rely on something. Context usually helps, but in technical documents, context can itself be contested.

Syntactic ambiguity (parsing issues): Classic example — "I saw the man with the telescope." Did I use the telescope to see the man, or did the man have the telescope? Programming languages avoid this with strict grammar rules and operator precedence.

Semantic ambiguity: "The function should return the largest value." Largest by what metric? In what ordering? For floating-point numbers, what about NaN or signed zeros?

Pragmatic ambiguity: What is left unsaid. In a conversation between colleagues who have worked together for years, massive amounts of information are implied. New team members, or an AI trying to implement from a spec, have no access to that shared mental model.

Compare this to Python, often praised for readability:

def process_data(data: List[float]) -> Optional[float]:
    if not data:
        return None
    return max(data)

Even without types, the behavior is unambiguous to anyone who knows Python's semantics. max([]) raises an exception, but here we explicitly handle the empty case. The return type hint further constrains expectations.

English has no equivalent of type hints, no compiler to catch inconsistencies, no unit tests for prose.

Why We Put Up With It (And Why We Shouldn't)

English has undeniable strengths. It is expressive, flexible, and culturally rich. It can convey emotion, nuance, humor, and poetry in ways that formal languages cannot. Shakespeare didn't write in lambda calculus for a reason.

But when the goal is reliable transmission of executable ideas — specifications, APIs, requirements, designs — those strengths become liabilities. Flexibility is another word for underspecification.

Anyone with real experience communicating complex ideas knows the pattern:

Write what seems like a clear English description.
Send it to a colleague.
Receive back an implementation that is technically correct but completely misses the intent.
Spend hours in discussion clarifying what was "obviously" meant.
Repeat.

This is why mature software organizations invest heavily in:

Precise requirements documents with measurable acceptance criteria
Formal methods (where the cost justifies it — e.g., aerospace, finance, medical devices)
Contract testing, property-based testing, and exhaustive specification
Code as the single source of truth, with comments used sparingly

The very existence of these practices is an admission that English is inadequate.

In physics and mathematics, we don't tolerate "it's approximately true, in the usual sense." We define terms rigorously. We prove theorems. We build models whose predictions can be falsified experimentally. The precision of the language enables the precision of thought and the reliability of results.

Programming aspires to the same rigor. That's why we have static type systems, formal verification tools like Coq or Lean, and languages with strong guarantees (memory safety, data-race freedom, etc.).

English remains the worst because it resists all such discipline. It evolves organically, embraces exceptions, and thrives on interpretation. It is a living, messy, human thing — wonderful for literature, conversation, and persuasion; disastrous for programming.

A Humble Remark

We don't need to abandon English. We need to recognize its limitations and use better tools where precision matters.

Next time you write a technical specification, ask yourself: Could this be misinterpreted in a way that leads to incorrect behavior? If the answer is yes (and it almost always is), add precision — through examples, edge cases, invariants, or even pseudocode.

Treat English as a high-level, lossy compilation target rather than the final executable specification.

Because in the end, the computer doesn't care about your opinions, your intent, or what "everyone knows" you meant. It executes precisely what you told it — in a real programming language.

And humans, despite our intelligence, are not much better than computers when the specification is written in the worst programming language of all: English.

We just hide our bugs better, and argue about them longer.

Introduction to RAG (Retrieval-Augmented Generation)

Wed, 01 Apr 2026 20:33:45 +0000

I’ve been diving into Generative AI lately, and one thing is clear: if you’ve spent any time with LLMs, you’ve probably run into their limitations. You ask an LLM a highly specific question about a new software library, your company's internal documents, or breaking news, and it either politely declines to answer or confidently makes up a complete lie.

The LLMs don't know about the recent information because they are limited to knowledge available till the time they were trained. And they don’t know about your company's internal info or documents because they were never trained on them and it is not safe because anyone with access to that model can get your internal information.

So, if you want the LLM to answer the questions based on information or data you provide to it without making it available publicly, how will you do it? Well there are plenty of ways by which you can make this possible. The ways are:

Fine-tuning: With the fine-tuning you can train the existing AI model on your private data and users can then ask questions based on that data. It is a high computation task, time consuming and is very costly.
Large Context Window Prompting: You provide all the information in your prompt and tell the LLM to answer based on your provided data only.

Although these methods can work they have their own limitations. Fine-tuning the LLM on your data is very costly and it requires high resources for computation and if your information is updated you have to fine-tune again which makes it an even more expensive approach. The LLMs have limited context window and when you query a LLM, you are not only sending a query to the user, you also send other stuff like system prompt and chat history along with your query. So, if you give large no. of information or data in prompt, you might hit the context window limit

Now, we need a solution which is cost and computation efficient and you can easily update your information without hitting the context window limit. This is where RAG comes into the picture.

What is RAG?

Retrieval-Augmented Generation (RAG) is an AI framework that improves LLM accuracy by fetching relevant, up-to-date information from external, trusted sources (like databases or company documents) before generating a response. It prevents misinformation ("hallucinations") by grounding the answer in verified data rather than relying solely on training data.

The RAG is implemented in two phases:

Indexing Phase: Indexing phase involves gathering the information or documents, generating embeddings and storing it in vector stores or vector DB.
Retrieval Phase: This phase involves retrieving the relevant information from vector store or DB and providing it to LLM for generating response based on the user's query.

Imagine you are hosting a major award show and you have a massive script that contains every single detail. This script includes the names of all the winners, the order of every performance, and every word you need to say. The problem is that the script is far too long for you to memorize entirely, and carrying the whole book on stage is too clumsy when you need to find a specific name quickly.

To solve this, you go through the script and pick out the most important facts to write on small cue cards. Each card contains just one specific piece of information, like the winner of a single category. You keep these cards organized in a small box so you can grab the right one at the right moment. When it is time to announce the Best Actor award, you don't flip through the whole script. You simply pull out the specific cue card for that award, read the name, and announce it to the crowd.

This process is exactly how RAG works. The long script represents your massive collection of data or documents. The difficulty of memorizing that script is the same as the limit on how much information an AI can "remember" or process at once. Breaking the script down into small cue cards is the same as turning your documents into small chunks. Storing those cards in a box is like putting those chunks into a vector store. Finally, finding the right card and reading the winner's name is the same as the AI finding the most relevant piece of information and using it to give you a perfect answer.

Components of RAG

A RAG pipeline consists of various components which makes the implementation of indexing phase and retrieval phase possible.

Document Ingestion & Indexing: This is responsible for gathering the information or documents from various sources and loading them.

Text Splitters: This is a crucial part of a RAG pipeline because this is responsible for dividing your large documents into smaller and manageable chunks. If we don’t convert large documents into small chunks it will not give us good results at the time of retrieval.

Vector Embeddings: This phase involves converting these small chunks into vector embeddings with the help of embedding models. This will help us to capture the semantic meaning of our texts.

Vector Stores & VectorDB: Stores embeddings and enables similarity search for fast information retrieval.

Retriever: Finds and returns the most relevant chunks from the database based on query similarity.

Prompt Augmentation Layer: Combines retrieved chunks with the user’s query to provide context to the LLM.

The Output: The LLM reads the context and provides highly accurate, hallucination-free answers.

Disadvantages of RAG

From the above discussions the advantages of RAG is clear but everything has its own limitations and disadvantages, and so does RAG. Here are some key disadvantages of RAG:

Retrieval Dependency and Quality: RAG depends entirely on the retriever component. If the retriever fetches irrelevant, outdated, or incomplete data, the LLM will generate poor-quality, inaccurate, or "hallucinated" answers.
Performance and Latency Bottlenecks: The extra step of searching a database (vector retrieval + generation) increases latency, making it unsuitable for some real-time applications.
System Complexity and Maintenance: Implementing and maintaining a RAG system involves managing databases, embedding models, and retrieval techniques. Updating knowledge bases requires complex re-indexing and re-embedding.
Data Security and Privacy Risks: RAG systems may expose sensitive or proprietary internal data to unauthorized users if access controls are not robustly implemented.
Contextual Understanding Failures: RAG systems can struggle with complex, interdisciplinary queries or connecting disparate pieces of retrieved information, leading to incoherent outputs.
Cost: Running RAG systems can be expensive, requiring both vector storage infrastructure and increased compute for the retrieval and generation processes
Chunking Errors: Improperly splitting documents can cause vital information to be missing or disjointed.
Debugging Difficulties: Due to the multiple moving parts (retriever + LLM), identifying the root cause of a poor answer is complex.

Conclusion

In short, RAG is a practical way to make AI smarter and more useful for your specific needs. Instead of spending a lot of time and money trying to "teach" an AI everything from scratch, RAG simply gives the AI the ability to look up facts from your own private documents before it answers a question, much like taking an open-book test.

The Ultimate Guide: Installing Ollama on Fedora 43

Tue, 31 Mar 2026 04:49:25 +0000

Running large language models (LLMs) locally isn’t just for the privacy-obsessed anymore—it’s for anyone who wants a snappy, custom coding assistant without a monthly subscription. If you’re rocking Fedora 43, you’re already using one of the most cutting-edge distros out there.

Here is how to get Ollama up and running with full NVIDIA acceleration and hook it into VS Code for a seamless dev experience.

There’s something uniquely satisfying about seeing your GPU fans spin up because your local AI is thinking. Let’s get you there in eight steps.

Step 1: Open the Gates (RPM Fusion)

Fedora is known for its commitment to free, open-source software, which means the proprietary NVIDIA drivers aren't there by default. We need to add the RPM Fusion repositories to get the "non-free" goodies.

Run this in your terminal:

sudo dnf5 install https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm 
sudo dnf5 install https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm

Note: We’re using dnf5 here, which is the faster, shinier version of the package manager standard in Fedora 43.

Step 2: The Driver Dance

Now, we install the NVIDIA drivers and the CUDA toolkit. This is what allows Ollama to talk to your GPU instead of making your CPU do all the heavy lifting.

sudo dnf5 install akmod-nvidia xorg-x11-drv-nvidia-cuda

A word of caution: Fedora moves fast. Sometimes, when the kernel updates, the NVIDIA modules need a moment to "catch up" (rebuild). If you update your system and things look wonky, it’s usually because the driver is still compiling in the background.

Step 3: The Classic Reboot

You know the drill. For the kernel to start using those new NVIDIA drivers, you need a fresh start. sudo reboot

Step 4: The Moment of Truth

Once you’re back in, let’s make sure Fedora and your GPU are on speaking terms. Run this command,

nvidia-smi

If you see a table showing your GPU name and VRAM usage, congratulations—you’ve passed the hardest part.

Step 5: Installing Ollama

Ollama makes installation incredibly easy with a one-liner script. This script handles the heavy lifting: it downloads the binary, creates an ollama user/group, and sets up a systemd service so it starts automatically.

curl -fsSL https://ollama.com/install.sh | sh

Step 6: Verifying the GPU Link

Just because Ollama is installed doesn't mean it’s using your GPU. It might be falling back to your CPU if it can't find the drivers. Let's check the logs:

journalctl -u ollama -b | grep "NVIDIA"

You’re looking for a line that confirms an NVIDIA GPU was detected. If you see it, you're golden.

Step 7: Your First Local Run

Let's test it with a lightweight, high-performance model. Qwen 2.5 Coder (0.5B version) is tiny but surprisingly "smart" for its size, making it perfect for a quick test.

ollama run qwen2.5-coder:0.5b

Once it downloads, you can chat with it directly in your terminal. Ask it to write a Python script; you'll be impressed by the speed.

Integrating with VS Code (The "Continue" Extension)

Running AI in a terminal is cool, but having it inside your IDE is where the real productivity happens. We’ll use the Continue extension, which is an open-source powerhouse for local AI.

Install the Extension: Search for "Continue" in the VS Code Marketplace and install it.
Configure Local Access: Open the Continue sidebar, click the gear icon (settings), and select your local config file.
Edit the Config: Replace or add the following to your config.yaml (or config.json depending on your version) to point it toward your local Ollama instance:

name: Local Config
version: 1.0.0
schema: v1
models:
  - name: Qwen2.5-Coder 0.5B
    provider: ollama
    model: qwen2.5-coder:0.5b
    apiBase: http://localhost:11434
    roles:
      - chat
      - edit
      - apply
      - autocomplete
      - embed

Final Thoughts

You now have a fully private, incredibly fast AI coding assistant running on your local hardware. No data leaving your machine, no latency issues, and total control.

Setting Up Custom Instructions for GitHub Copilot

Thu, 21 Aug 2025 14:42:28 +0000

Your company has just purchased GitHub Copilot licences for the entire development team.
The promise is appealing: faster delivery, less repetitive work, more focus on the important stuff.

But after a few weeks… problems start to emerge:

Code that is inconsistent with project standards.
Missing unit tests.
Insecure implementations in critical areas such as cookies, authentication, or input validation.

This happens because Copilot, by default, does not know your internal rules.
The solution: create a shared custom instructions file that every developer can use.

1. What are “Custom Instructions” for Copilot?

Instead of giving instructions in every comment or prompt, you can define a persistent set of rules that Copilot will always consider.
When it suggests code, it will then respect:

Project style guidelines.
Security practices.
The correct framework and internal libraries.
Linter rules.

These instructions can be stored in a file (e.g., .copilot-instructions.md) and distributed to the whole team.

2. Example `.copilot-instructions.md` file

GitHub Copilot – Corporate Instructions

Style and Linter
- Always follow the rules from `.eslintrc.json` for JavaScript and `.pylintrc` for Python.
- Use single quotes in JavaScript/TypeScript.
- Always end statements with `;` in JS/TS.

Security
- For cookies: set `httpOnly`, `secure`, `sameSite: strict`, and `maxAge`.
- Never include passwords or secrets in code.
- Validate all external input using patterns from `utils/validators`.

Tests
- Always generate unit tests alongside new code.
- Use Jest for JS/TS projects and pytest for Python.
- Minimum coverage: 90%.

Internal Libraries
- Use `logger` for logs, not `console.log`.
- Use `fetchWithAuth` instead of `fetch` for authenticated HTTP calls.

Other
- Document every public function with JSDoc or Python docstrings.
- Avoid external dependencies not listed in `approved-deps.json`.

3. How to implement this across your team

Create the file .github/.copilot-instructions.md at the root of your project (create .github folder if you don't have it).

Share it in the base repository or in your project templates.

Configure Copilot so that it applies these rules: If you use Visual Studio Code, open the file at the start of a session and paste its content into Copilot’s “Custom Instructions” settings.

If your team uses GitHub Copilot Chat, paste the content as initial context.

In enterprise setups, include it as part of onboarding scripts or IDE initialisation steps.

4. Example in practice

Without instructions, Copilot might produce:

res.cookie('sessionId', id);

With .copilot-instructions.md in place, it will suggest:

res.cookie('sessionId', id, {
  httpOnly: true,
  secure: process.env.NODE_ENV === 'production',
  sameSite: 'strict',
  maxAge: 1000 * 60 * 60 // 1 hour
});

5. Benefits

Consistency: all developers receive aligned suggestions.
Security: reduced risk of unsafe implementations.
Less friction: no need to repeat the same instructions in every prompt.
Faster onboarding: new joiners produce better code from day one.

Conclusion

Copilot is not a senior developer – it needs context.
A corporate instructions file turns that “intuition” into a set of explicit rules, helping Copilot to produce code that is secure, consistent, and compliant with your organisation’s standards.

For more details, see the Github Docs.

Amazon Q CLI for Code Review: Focus on What Changed, Not Everything

Fri, 16 May 2025 19:48:30 +0000

Some AI-powered coding assistants already support code reviews, but most of them tend to review an entire workspace or just the currently open file. In real-world scenarios though, code reviews are often based on pull requests—where we only need to review changes between two branches, not the whole project. For example, reviewing just the differences between a hotfix branch and main.

That got me thinking: wouldn’t it be great if an AI coding assistant could handle that kind of focused review? At least as a first layer—giving us a detailed AI-generated review of the changes before we jump in manually. That way, human reviewers can just focus on refining things further instead of starting from scratch.

What I Built

One of Amazon Q Developer’s cool features is its CLI and MCP (Model Context Protocol) support. So I thought: why not use Amazon Q CLI to compare two branches—say, hotfix and main—and then have it go through the changed files one by one, review them, and finally compile the feedback into a single file using MCP as well? That way, whoever’s reviewing the PR can read the AI’s review first before doing their manual checks.

Demo

Youtube Demo

Code Repository

Code Review with Amazon Q Developer CLI

How I Used Amazon Q Developer

I used Amazon Q Developer as the first layer of code review—comparing one branch to another, like from hotfix to main. This helps make the review process smoother, more effective, and scalable—especially when combined with a follow-up manual review. What makes it even more exciting is that Amazon Q Developer can both generate code and review it too. Pretty handy, right?

The AI Awareness Gap: Living in the Tech Bubble While the World Catches Up

Wed, 09 Apr 2025 22:43:07 +0000

As a 25-year-old who has traversed the path from designer to full-stack developer, I've found myself increasingly immersed in what I call the "AI bubble." Inside this bubble, ChatGPT, Claude, Perplexity, and dozens of specialized AI tools are everyday companions—so commonplace that it's easy to forget that not everyone shares this reality.

The Revelation

I had my wake-up call during a family dinner last month. My aunt, a seasoned corporate lawyer with 20 years of experience, was complaining about spending hours drafting preliminary case analyses. When I casually mentioned she could use ChatGPT to create initial drafts, her expression shifted from exhaustion to confusion.
"You mean that robot thing that makes pictures?" she asked.
This wasn't an isolated incident. My uncle, who meticulously researches investment opportunities, spent weeks gathering information about gold monetization schemes. When I showed him how Perplexity could compile and synthesize that research in minutes, he was simultaneously amazed and slightly irritated at the hours he'd wasted.
These moments made me realize: the gap in AI literacy isn't just between tech and non-tech sectors—it's a chasm.

The Surprise Within Tech

What's more surprising is finding this gap within the technology industry itself. In my previous role, I discovered that one of my managers—a senior developer—wasn't even aware of GitHub Copilot and how it integrates with VS Code. When I used it to accelerate my coding, he expressed concern that the company would reprimand me for "using AI to generate code and not writing it on my own."
This disconnect extended to our business analyst who had no idea about any AI tools. Instead of comprehensive documentation, I received random notes strung together with basic diagrams (she didn't know Figma either).
The most egregious example came when our company, despite limited knowledge about generative AI, decided to build their own LLM from scratch. They wasted countless months and substantial resources on this venture when all they really needed was a helpful chatbot trained on company data to help users learn more about their products. A pre-trained model with some fine-tuning would have accomplished this goal in a fraction of the time.
It wasn't just about wasting time but also squandering money. These valuable resources could have been directed toward more pressing needs, like rewriting legacy code for current frameworks. The irony reached its peak when the company later initiated massive layoffs, citing how "AI reduces the workload of employees, hence we need fewer employees to do the same amount of work"—all while most of the decision-makers demonstrated a fundamental misunderstanding of the very technology they used to justify cuts.
This contradiction reflects a broader pattern in the industry: organizations racing to implement AI technologies—or use them as justification for restructuring—while many of their decision-makers don't understand what these tools actually do or how they could be effectively integrated into existing workflows.

Bridging the Gap

I've started to see this awareness gap as a responsibility for those of us inside the bubble. Not in a condescending "let me show you the future" way, but through practical demonstrations that connect directly to people's daily challenges.
When I showed my aunt how to use an AI assistant to create the first draft of a standard cease and desist letter, she didn't just see a cool technology—she saw 45 minutes of her day reclaimed. That's the language that matters.
The most effective bridge-building moments haven't come from explaining how large language models work or discussing transformer architectures. They've come from simply sitting next to someone struggling with a repetitive task and saying, "Can I show you something that might help?"

Looking Forward

As AI tools become more powerful and more specialized, this awareness gap risks widening rather than narrowing. The sheer volume of new applications makes it challenging even for those within the bubble to stay current.
Perhaps the most important conversation isn't about artificial intelligence at all—it's about human communication. How do we translate the benefits of these tools into terms that resonate with daily human experiences? How do we ensure that technological literacy becomes a bridge rather than another dividing line in society?
For now, I'm starting small. I've scheduled a "Tech Thursday" lunch with my team where we each share a tool we've discovered. I'm helping my aunt create templates for her most common legal documents. And I'm learning to step outside my bubble more often, to remember that what seems obvious within my daily context remains mysterious—and potentially transformative—to many others.
The AI revolution isn't just about building better models or more impressive applications. It's about ensuring that the benefits reach beyond the bubble, into courtrooms, classrooms, small businesses, and family dinner tables. That's the gap we need to close.

Useful Tools for LLM Application Development

Thu, 20 Feb 2025 11:09:43 +0000

AI is taking over today’s tech world. Everyone needs to integrate AI into their business, develop AI applications, etc. I’m not here to explain what AI is, its subfields, or what an LLM is — none of that bla bla bla. Let’s get straight to the point. My topic is Generative AI and Agentic AI, specifically LLMs and Multi-Agent Systems (MAS). When developing LLM applications and MAS, we need to validate LLM outputs, monitor our agents, and integrate with various tools and services. I’ll share some useful tools and libraries for building these kinds of applications. Everyone knows about LangChain and LlamaIndex. So, I am not going to talk again about those two frameworks.

1. Instructor

Instructor is used to get structured outputs (Type Safe) from LLMs. It is built on top of Pydantic. This library has the support for streaming responses, and it is available in Python, TypeScript, Go, Ruby and Elixir. Also, it can be used with many LLMs including self-hosted models. You can simply define a Pydantic model as a response model use it with the instructor to get the output as you need. Instructor also supports Jinja templates which allow you to create dynamic prompts. Also, this can be used with LogFire to monitor performance of the application. In their documentation you can find a bunch of examples of how to use the Instructor.

2. Composio

When building AI agents, we need tools that enhance their capabilities. Composio is a great option—an integration platform for AI agents that provides access to over 250 tools. It allows seamless integration with services like GitHub, Jira, Salesforce, Gmail, Shopify, and more. Composio supports various frameworks, including LangChain, LlamaIndex, CrewAI, AutoGen, and LangGraph, while remaining LLM-agnostic. It also offers authentication mechanisms such as OAuth and JWT. Additionally, Composio enables automatic action execution through its built-in triggers, making AI workflows more efficient and automated. Available in both free and paid plans.

3. AgentOps

When developing AI agents, it is crucial to monitor their performance, track token usage, and measure response times. AgentOps is an observability platform that enables you to monitor, debug, test, audit, and deploy your AI agents effectively. It supports various agent frameworks, including CrewAI, LlamaIndex, LangChain, and AutoGPT, along with multiple LLMs. AgentOps helps track token usage, monitor costs, and provides clear visualizations for better insights. Very easy to use. With two lines of code, you can add AgentOps to your application. It comes with a user-friendly interface and is available in both free and paid versions. Also, there are similar observability tools like LangFuse, LangTrace, etc.

4. Parlant

Parlant lets you create and control AI Agent behaviors to suit your needs. You can define unique Guidelines for each agent, specifying how they act in different situations, set up a custom word dictionary for every agent, and create context-based variables to store data. If you’re building AI Agents for tasks like Customer Support, Parlant is worth considering. This framework also supports for tool calling agents which provide access to third party services and APIs. Parlant operates on an Event-Driven model, unlike the traditional request/response model. This approach makes conversations feel more natural, allowing agents to respond whenever needed. Security is also a strong point of Parlant. It uses Lakera Guard for jailbreak protection. While Parlant has a small but growing community, its capabilities make it a solid choice for AI-driven interactions. There is one drawback. You can change the LLM provider. But you can’t change which model to use. You have to use the model selected by Parlant developers. But they will include the ability to change model versions in the near future.

5. LM Studio

LM Studio gives you the ability to run LLMs locally. and supports for various LLMs. This is most like Ollama. But there are some differences. LM Studio comes with a GUI. You can explore models within the UI. Additionally, LM Studio includes a built-in chat feature and allows you to start a server with your chosen model in just one click. LM Studio is available for Windows, Linux and Mac OS. The tool can analyze your PC’s specifications and recommend the most suitable quantized version of a model. CrewAI also supports LM Studio.

6. LangFlow

LangFlow is an open-source, low-code tool designed to simplify the development of RAG applications, AI agents, and workflows that can interact with any API, model, or database. It provides an easy-to-use GUI with drag-and-drop components, allowing you to build LLM applications effortlessly. LangFlow can be used both locally and in the cloud. It supports integration with observability tools like LangSmith, LangFuse, and LangWatch, helping you monitor your applications. LangFlow also supports for many tools that can connect your app with useful third-party services like Google Drive, FireCrawl, Confluence, Serper, etc. To make getting started even easier, LangFlow includes pre-built templates, allowing you to quickly set up and launch your application.

Conclusion

Building AI applications, whether LLM-based or Multi-Agent Systems (MAS), requires the right tools for validation, monitoring, and integrations. AI is evolving very fast. Staying updated is crucial to gain its full potential. We should be aware of tools that can enhance our AI application development. Beyond the tools covered in this article, many others exist that can enhance AI development. Explore these options, experiment, and take your AI projects to the next level.

Coder Legion - Recent posts tagged genai

From Career Confusion to Career Clarity: Building Supernova AI with Google Gemini

What should I pursue after graduation? Which skills should I learn? Which certifications are actually relevant? And where do I even begin?

The Story Behind Supernova AI

What Is Supernova AI?

How Supernova AI Works

Why Google Gemini 2.5 Flash?

What Makes Supernova AI Different?

Building for Accessibility and Equal Opportunity

From Learning About Gen AI to Building with It

Looking Ahead

Every Career Journey Deserves a Clearer Starting Point

From 4,000+ Applications to 250 Builders: Building a Multi-Agent Video Pipeline at the Google DeepMind Bangalore Hackathon

TL;DR

The selection

The idea: merging two tracks instead of picking one

What building under a deadline like this actually felt like

The outcome

Why I'm writing this up

Are we hiring developers who can build, or developers who can prompt?

English is The Worst Programming Language

Precision: The Foundation of Reliable Computation (and Communication)

The Many Ways English Fails as a Specification Language

Ambiguity at Every Level

Why We Put Up With It (And Why We Shouldn't)

A Humble Remark

Introduction to RAG (Retrieval-Augmented Generation)

What is RAG?

Components of RAG

Disadvantages of RAG

Conclusion

The Ultimate Guide: Installing Ollama on Fedora 43

Step 1: Open the Gates (RPM Fusion)

Step 2: The Driver Dance

Step 3: The Classic Reboot

Step 4: The Moment of Truth

Step 5: Installing Ollama

Step 6: Verifying the GPU Link

Step 7: Your First Local Run

Integrating with VS Code (The "Continue" Extension)

Final Thoughts

Setting Up Custom Instructions for GitHub Copilot

1. What are “Custom Instructions” for Copilot?

2. Example .copilot-instructions.md file

3. How to implement this across your team

4. Example in practice

5. Benefits

Conclusion

Amazon Q CLI for Code Review: Focus on What Changed, Not Everything

What I Built

Demo

Code Repository

How I Used Amazon Q Developer

The AI Awareness Gap: Living in the Tech Bubble While the World Catches Up

The Revelation

The Surprise Within Tech

Bridging the Gap

Looking Forward

Useful Tools for LLM Application Development

1. Instructor

2. Composio

3. AgentOps

4. Parlant

5. LM Studio

6. LangFlow

Conclusion

2. Example `.copilot-instructions.md` file