Forem: leslysandra

GemmaChallenge: Build a Socratic Study Buddy with Gemma 4

leslysandra — Mon, 18 May 2026 01:29:33 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

I built a local Socratic Study Buddy application. It pairs the localized inference engine of LM Studio with a custom-built Streamlit Web UI frontend. Instead of acting as a lazy "answer engine" that does a student's homework for them, this tool forces the underlying Gemma 4 model to plan pedagogical strategies and use structured dialogue to guide critical thinking.

Demo

Here is how the complete architecture interacts within the custom Python frontend workspace:

Check out more details in this blogpost :)

Code

The entire layout—including the Python automation scripts, system prompt templates, configurations, and the Streamlit frontend architecture—is completely open-source:
👉 Check out the GitHub Repository Here

How I Used Gemma 4

Gemma 4 powers the core logic of this project through its Chain-of-Reasoning process. Gemma 4 has the capacity for a native Chain-of-Reasoning process.

Instead of jumping straight to an answer, Gemma 4 works through logical steps internally before it speaks. This makes it a perfect mentor. While other models might just do your homework, Gemma 4 is trained to identify where you are stuck and nudge you toward the solution.

Team Submissions:

Developed by @leslysandra along gemini and claude.

Build a Socratic Study Buddy with Gemma 4: A Beginner’s Guide to Running AI Locally

leslysandra — Mon, 18 May 2026 01:21:13 +0000

The landscape of AI has shifted from "bigger is better" to "smarter is better." We are entering the era of intelligence-per-parameter—a metric of how much reasoning power is packed into a compact model. Gemma 4, built on the latest research from Google DeepMind, brings high-level, multi-step reasoning directly to your own hardware.

This guide will show you how to build a Socratic Study Buddy—a tutor that doesn't just give you answers but helps you think through problems—while keeping your data 100% private using a custom local web interface.

What I Built

I built a local Socratic Study Buddy application. It pairs the localized inference engine of LM Studio with a custom-built Streamlit Web UI frontend. Instead of acting as a lazy "answer engine" that does a student's homework for them, this tool forces the underlying Gemma 4 model to plan pedagogical strategies and use structured dialogue to guide critical thinking.

Why Gemma 4 Matters for Learning

Gemma 4 is a "Thinking Model." Older AI models functioned like advanced autocomplete, predicting the next word based on patterns. Gemma 4 has the capacity for a native Chain-of-Reasoning process.

Choosing Your Brain: The Official Model Sizes

To run this locally, you need to pick the right "size" for your computer. Gemma 4 comes in four official variants:

Effective 2B (E2B): Tiny and lightning-fast. Optimized for high-end phones or older laptops with 4GB–8GB of RAM.
Effective 4B (E4B): The "Sweet Spot" for most modern laptops with 8GB–12GB of RAM. This is the entry point for high-quality image and audio understanding.
26B A4B (Mixture-of-Experts): The speed demon. It has 26 billion parameters but only uses 4 billion at a time to answer. You get high-quality reasoning with fast speeds. Requires 16GB–24GB of RAM.
31B Dense: The flagship. This is the smartest model in the family, providing maximum reasoning quality for complex math. Use this if you have a powerful workstation with 32GB+ of RAM.

Setup: Bringing the Brain to Your Frontend

Instead of staying restricted to standard desktop setups, we bridge the model into a lightweight web dashboard.

Step 1. Weight Retrieval & Backend Hosting

1. Search for Gemma 4: Open LM Studio and click the Magnifying Glass. Type "Gemma 4".

2. Select a GGUF: Look for files labeled GGUF (a compressed file format that lets heavy models run on consumer hardware).

3. Choose Your Quantization: Look for Q4_K_M (a version that balances intelligence with low memory usage).

4. Start the Local Server:: Head to the Local Server tab in LM Studio, load your downloaded model, ensure your system prompts are injected, and start the service on port 1234. Turn GPU Offload to "Max" to leverage your graphics card.

Step 2. Running the Custom Web UI

To spin up the clean web chat interface shown below, clone the repository, install the dependencies, and launch the frontend file:

pip install streamlit openai
streamlit run app.py

Demo

Here is how the complete architecture interacts within the custom Python frontend workspace:

The UI Environment Overview

The implementation splits backend configuration details directly away from the active learning space, allowing seamless swaps between running models:

The Project: The Socratic Study Buddy Prompt

In your local configuration workspace or the core application prompt files, we pass this instruction using the official <|think|> control token sequence to isolate the reasoning channel:

<|think|>
You are an expert academic tutor. You are forbidden from giving the final answer. Instead, use your internal reasoning to identify the core concept the student is struggling with and ask guiding questions.

The "Thinking" Advantage in Action

When you ask the web component: "I don't understand how recursion works in coding."

Gemma 4 enters its Internal Thought Channel. Within your local terminal execution or dashboard view, you will see it process its strategy before printing its output:

Gemma 4 (Internal Reasoning): The user wants to know recursion. Giving code directly violates the Socratic constraint. I will use a structural stack analogy, like a line of people or nesting boxes, to force them to identify the concept of a terminating condition.

Tutor Output Response:

"To understand recursion, we first need to understand a 'base case.' If you were standing in a line of people, how would you know your position without counting everyone yourself?"

Beyond Chat: Real-World Visuals

One of the best ways to study is to visualize logic. You can ask your Study Buddy to "Draw the logic of this concept." It will generate clean Mermaid.js code directly in the conversation panel:

User: "Show me the logic of the Socratic method we just used."
Gemma 4: "Here is the flowchart of our session:"

graph TD
    A[Student Asks Question] --> B{Model Thinks}
    B --> C[Identify Missing Concept]
    C --> D[Ask Guiding Question]
    D --> E[Student Responds]
    E -->|Correct| F[Nudge to Next Step]
    E -->|Incorrect| G[Simplify Analogy]

Code

Digital Sovereignty & Ethical AI Safety

Building with open-source models like Gemma 4 is a foundational ethical choice:

Privacy (Digital Sovereignty): Every question you ask stays on your machine. Your learning struggles aren't being used to train a corporate model.
The Trade-off: Unlike cloud models, a local model is your responsibility. You must verify its facts, as it doesn't have an external "safety filter" monitoring the conversation.

Advantages:

Transparency: You can inspect the weights and the "thinking" process, which is impossible with closed-source models.
Privacy: Since it runs locally in LM Studio or on your private GKE cluster, your data never leaves your environment.

Disadvantages:

Resource Intensity: High-reasoning models still require significant compute power compared to lightweight "dumb" bots.
Guardrail Responsibility: Unlike a managed API that filters every word, an open-source model places the "Safety Filter" responsibility on you. You must implement your own output classifiers to ensure the model stays within educational boundaries.

Conclusion

You’ve gone from raw local model files to running a custom, world-class educational reasoning platform directly on your laptop. You’ve built an app that doesn't just echo stored training text—it actively fosters critical thinking.

Your Challenge: Use your newly built Web UI Study Buddy to tackle a topic you’ve always found intimidating—maybe organic chemistry or financial engineering. How does having an interface powered by a "Thinking Model" change the way you interact with complex documentation?

Next Steps: Ready to scale from a chat interface to fully autonomous pipelines? Check out the Pi Coding Agent by Patrick Loeber—a minimal terminal client that bridges local Gemma 4 instances straight to your terminal environment so it can write, debug, and run code directly for you!

Your Prompts are Legacy Code Now: The Google Cloud Next '26 Developer Breakdown

leslysandra — Tue, 05 May 2026 17:32:00 +0000

The era of "chatting with an LLM" is officially legacy.

I've attended the Google Cloud Next ‘26 Developer Keynote, and saw the pivot point. We aren’t just writing better prompts anymore; we are architecting Production-Ready Autonomous Systems.

Google's showcase centered on a multi-agent system coordinating a full city-scale marathon simulation—Planner, Evaluator, and Simulator agents working in concert.
But the marathon wasn't the point. The architecture behind it is what you need to steal for your own systems to move from "vibes" to engineering rigor.

From Hype to Architecture

Feature	What It Replaces	Why It Matters
ADK (Agent Development Kit)	Custom agent SDKs	Provides a standardized, modular framework for building autonomous "skills."
MCP (Model Context Protocol)	Brittle, hard-coded glue code	Enables native, secure service integration across the entire Google Cloud ecosystem.
Memory Bank	In-context hacks & long prompts	Delivers true, long-term stateful memory so agents "learn" from previous executions.

🏗️ Shift 1: The Standardized Framework (ADK & MCP)

Production agents require a modular stack.

Agent Development Kit (ADK): Announced at Next '25, this is your SDK for autonomy. It allows you to build agents with specific "Skills" (YAML/Markdown) and "Tools." And in 2026 is the core for building Agentic Systems.
Model Context Protocol (MCP): Every Google Cloud service is now MCP-enabled. Your agents can now "speak" directly to Maps, BigQuery, or Vertex AI (today is called, Agent Platform) without you writing brittle glue code.
A2UI (Agent-to-User Interface): A new standard for generative UI. Instead of walls of text, agents dynamically render Flutter or Angular components based on the task context.

Monday Morning Advice: Use ADK to wrap your existing Python logic. It turns a script into a "Skill" that any agent in your ecosystem can call.

# ADK Agent skeleton (Conceptual)
agent = ADKAgent(
    name="Planner",
    skills=["marathon_routing.yaml"],
    tools=[MapsClient, BigQueryClient],
    memory=MemoryBank.connect("run-session-01")
)

🧠 Shift 2: Context Engineering (Memory Bank & Event Compaction)

The biggest bottleneck for production agents has been "forgetting" or hitting token limits during complex reasoning.

The Memory Bank: A fully managed service that allows agents to store long-term learnings. If an agent fails a simulation in Run A, it "remembers" the failure in Run B.
Event Compaction: This allows an agent to periodically summarize its own workflow using Gemini. It keeps the context window lean and prevents crashing during long-running tasks.

Monday Morning Advice: Implement Event Compaction for any reasoning loop longer than ~15 steps or any workflow running >10 minutes. If you've ever hit a 400 context error, this is your fix.

🛡️ Shift 3: Governance (Agent Identity & Gateway)

The real risk isn't just malice—it's an agent with Write access to production following a hallucinated plan.

Agent Identity: Individual agents now have unique, immutable credentials.
Agent Gateway: This acts as a centralized blast radius limiter. You can enforce "Read-Only" policies on a per-agent basis, ensuring a Planner agent can't accidentally spend your entire OPEX budget.

Monday Morning Advice: Before deploying, map your Agentic Attack Surface. Use the Agent Gateway to strip "Write" permissions from any agent that only needs to analyze data.

🚀 Start Architecting Now

Don't just watch the recording; break the code. Google has released the hands-on materials to replicate the "Agentic Marathon" architecture today.

Official CodeLab (guided): Next ‘26 Developer Keynote:Building ADK Agents with Skills and Tools

The question isn't whether your company will adopt agentic systems—it's whether you'll be the one who architected them or the one who was handed them.

Which one are you building toward? Let’s discuss in the comments.

Andrew Ng's new open-source project, Context Hub, attempts to solve a problem every API provider has right now whether they know it or not. Coding agents are getting your API wrong.

leslysandra — Mon, 23 Mar 2026 19:41:08 +0000

Mike Chambers for AWS

Mar 10

Context Hub Has 68 APIs. Add Yours.

#ai #api #productivity

Comments 1

6 min read

Gemini 3.1 Pro & "Nano Banana 2": A Technical Review and Real-World Tests for Devs

leslysandra — Sat, 28 Feb 2026 02:51:27 +0000

While the hype around new AI models in the last week of February has everyone distracted generating "cool images" 🍌🍌🍌, the real workhorse for developers was quietly released: Gemini 3.1 Pro.

As an AI educator, I was incredibly curious about these new models, so I put them through a series of specific stress tests: advanced reasoning in ARC-AGI-2, the new 65k output token limit, and UI text consistency with Nano Banana.

If you are a dev, a data scientist, or a tech enthusiast building digital products, here is exactly what you need to know.

Gemini 3.1 Pro: Your New Logic Sidekick

Launched this February 2026, the most interesting thing about Gemini 3.1 Pro isn't just that it's "smarter." It's the architecture. Google is promising an impressive 77.1% score on ARC-AGI-2.

If you're new to AI benchmarks: ARC is the "final boss" of reasoning. Most models just memorize answers from their training data; ARC forces them to solve entirely novel patterns they have never seen before.

The Pain Point it Solves: The Output Limit

Have you ever asked an AI to refactor a 2,000-line file, only for it to cut off halfway through? It leaves you with a broken JSON, forcing you to type "continue..." while praying it doesn't lose context.

Gemini 3.1 Pro raises the output limit to a massive 65,536 tokens.

The Test: I asked it to refactor a Flask codebase (three separate Python files) in a single shot.

The prompt:
Act as a Senior Backend Architect. You are tasked with refactoring a legacy Flask application where views, models, and business logic are tightly coupled. You must migrate this entire codebase to a modern FastAPI (Asynchronous) architecture using Pydantic v2 for schema validation and SQLAlchemy 2.0 (Async) for the data layer.
Strict Requirements:
No Summarization: I need the full, complete implementation. Do not use placeholders like # ... rest of code here.
Architectural Separation: Clearly separate the code into Pydantic Models (Schemas), Database Models, and API Endpoints (Routers).
Logic Integrity: Maintain 100% of the original business logic, including complex relationships like tags, favorites, and follower/user relationships.
Modern Standards: Use Python type hints throughout, implement async/await for all DB operations, and utilize SQLAlchemy 2.0's Mapped and mapped_column syntax.
Output Format: Generate a single, massive code block using comments (e.g., # models.py, # schemas.py, # main.py) to indicate the suggested file structure for a production-ready repository.

With Gemini 3.1 Pro and the 65k tokens enabled, the generation just keeps going. By the time it finishes, it has written:

All Pydantic schemas (UserSchema, ArticleSchema…)
The asynchronous DB configuration.
All CRUD endpoints converted to async def.

(If you want to try this yourself, I used the flask-realworld-example-app repo. I fed it conduit/articles/views.py for complex route logic, conduit/articles/models.py, and conduit/user/models.py for relational database models).

Testing the Logic: The ARC-AGI-2 Challenge

To see if it actually "reasons," I used the new parameter thinking_mode='medium'. This allows the model to "think" before responding, perfectly balancing speed and intelligence.

The Test: I gave it a medium-level "trace and fill" test (essentially a hidden pattern puzzle).

The prompt:
Observe the transformation pattern between the input and output arrays. Identify the underlying rule and solve the final case.
Example 1:
Input: [1, 0, 0, 0, 2]
Output: [1, 8, 8, 8, 2]
Example 2:
Input: [0, 1, 0, 2, 0]
Output: [0, 1, 8, 2, 0]
Final Problem:
Input: [0, 0, 1, 0, 0, 0, 2]
Output: ?
Explain your reasoning.

Did you catch the hidden sequence? Are you convinced by Gemini 3.1 Pro’s result?
🤫 Psst... the hidden pattern is: Convert any zero (0) located between a 1 and a 2 into an eight (8). ⚡️⚡️⚡️

I tested this on older versions of Gemini, and the majority failed to get the correct answer. 🤓🤓🤓

Note: AI models don't 'see' these images the way we do. I passed the puzzle raw as 2D JSON matrices to prevent basic image recognition and force the model to use pure mathematical reasoning.

2. Nano Banana 2: Fast, Furious, and... Can it Read?

Let's move on to the model with the funny name 🍌🍌🍌. Nano Banana 2 (officially Gemini 3.1 Flash Image) promises Pro-level quality at Flash-level speeds.

For Frontend Devs, there are two game-changers here:

Text Rendering: Finally, an AI that doesn't write alien hieroglyphs.
Search Grounding: It can search Google before generating the image.

Try It Yourself (Hands-on Tests)

I encourage you to open Google AI Studio or the Gemini App and try this right now.

Test A: The UI Mockup (Perfect for Frontend)

Image models are notoriously bad at prototyping interfaces.
Let's test this prompt on Nano Banana 2:

Prompt: A high-fidelity mobile banking dashboard. The header says 'Total Balance: $14,250.55'. A green button at the bottom says 'Transfer Funds'. Dark mode, material design.

It generated in under 2 seconds, and the text was flawless! Imagine connecting this to your workflow, essentially "compiling" text into UI mockups in real-time for your clients.

Test B: Search Grounding (What wasn't in the dataset)

This is the killer feature. I asked for something that didn't exist when the model was trained—something based on today's breaking news (simulated).

Prompt: A realistic photo of the stage at today's tech convention, showing the leaked triangular camera design of the new VR device.

The model actively searched for the reference and generated the correct design. This opens the door to generating dynamic content based on real-time, real-world events.

Extra: One more test

To truly push Nano Banana 2's new features to the limit, I crafted a highly complex prompt. Here is the prompt and the resulting image:

Prompt: Using the two uploaded images for character reference, create a single, high-quality 4K vertical infographic titled 'The 1920s Lunar Landing.' The main subject is the person, standing on the lunar surface, dressed as a vintage 1920s-style astronaut in a polished brass helmet and detailed leather straps. They must retain their exact facial features. Next to them, integrate the cat (exactly as referenced in the second image) into its own miniature, customized vintage brass and glass bubble helmet. The cat is sitting upright near a clear, legible sign that says: 'One small step for a Flapper, one giant leap for Feline-kind.' The overall art style must be sophisticated 1920s Art Deco. The dramatic lighting from the Earth in the background must realistically reflect off both of their brass helmets, showcasing intricate texture and form.

This is a demanding prompt because it requires three distinct levels of advanced reasoning:

Parallel Subject Preservation: I uploaded two reference photos (one of me, one of my cat), and the model successfully maintained both of our exact identities.
Multitasking Lighting Logic: It had to calculate complex light reflections from the Earth onto two different brass helmets.
Complex Spatial Relationships: It logically placed the cat "next to me" and "near the sign," maintaining perfect scene coherence.

Conclusion: Where Should You Start?

Sometimes, we hesitate to adopt new tools, assuming they are "too complex" or "too expensive." The reality is that this technology is more accessible than ever.

My recommendation to start experimenting today:

If you have heavy Python scripts or complex RAG pipelines, migrate to Gemini 3.1 Pro. That 65k output token limit will give you immense peace of mind.
If you are building any app that generates images, switch to Nano Banana 2. The sheer speed combined with perfect text accuracy will finally allow you to create highly usable interfaces.

Try it yourself 😉. Here are the launch links and references to get you started:

Gemini 3.1 Pro: A smarter model for your most complex tasks https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-3-1-pro/
Nano Banana 2: Combining Pro capabilities with lightning-fast speed https://blog.google/innovation-and-ai/technology/ai/nano-banana-2/

Last part! (3 out of 3) to Get started with Gemini CLI

leslysandra — Mon, 09 Feb 2026 19:21:49 +0000

Part 3: Mastering Gemini CLI – Content Creation, Learning, and Multimodality

leslysandra ・ Feb 9

#gemini

Part 3: Mastering Gemini CLI – Content Creation, Learning, and Multimodality

leslysandra — Mon, 09 Feb 2026 19:19:37 +0000

Welcome to the finale of our Gemini CLI series!

In Part 1, we installed the CLI and set up our environment. In Part 2, we learned about coding workflows, data analysis and extensions in workspace.

Now, we are going to have some fun. We are moving beyond simple text and code. We are going to explore multimodality (handling images, audio, and PDFs) and turn your terminal into the ultimate Personal Tutor.

If you think the command line is just for boring text, this post will change your mind.

1. Content Creation with Extensions (The "NanoBanana" Workflow)

One of Gemini's greatest strengths is that it is multimodal—it understands code, text, images, and audio natively. But how do we harness this in a terminal?

We use extensions.

Google recently introduced a robust extensions framework that lets you plug almost anything into the CLI. A popular community extension for creative content generation is NanoBanana.

This tool connects your CLI to image generation models (like gemini-2.5-flash-image), allowing you to create placeholder assets, icons, or visual concepts without leaving your code editor.

How to Connect NanoBanana

Giving your CLI "eyes for images" takes just one command.

Step 1: Install the Extension
Run this command in your terminal to pull the extension from the repository:

gemini extensions install https://github.com/gemini-cli-extensions/nanobanana

Step 2: Restart and Verify
Restart your CLI. You can now use specific slash commands like /generate or /icon.

Step 3: Generate Creative Assets
Let’s say you are building a mobile app and need a quick placeholder icon for a "Cyberpunk Todo List."

The Prompt:

"Using the NanoBanana extension, /generate an app icon for a productivity app with a cyberpunk neon aesthetic. Make it simple, vector style, on a black background."

Why this matters:
You are orchestrating creative workflows without leaving your coding environment. You become a "technical artist" straight from the command line, rapidly prototyping UI elements while you code the backend.

Ready:

2. Gemini CLI as Your Personal Tutor

The most underrated feature of Gemini 3 Flash is its massive Context Window. It can read huge files—like entire books or long PDF research papers—in seconds.

This turns the CLI into a powerful study buddy that creates active learning materials for you.

Scenario: The University Student / Self-Learner

Imagine you have a 50-page PDF called Advanced_Algorithms.pdf and you have an exam tomorrow.

Step 1: The Summary
Don't read the whole thing linearly. Ask Gemini to break it down.

gemini "Read @Advanced_Algorithms.pdf. Summarize the key concepts by chapter. Use bullet points and simple language."

Step 2: Active Recall (Flashcards)
Passive reading is inefficient. Force yourself to remember with AI-generated flashcards.

gemini "Based on @Advanced_Algorithms.pdf, generate 10 flashcards. Format them as: 'Front: [Question] | Back: [Answer]' so I can import them into Anki."

Step 3: The Mock Exam
Test your knowledge immediately.

gemini "Act as a strict professor. Create a 5-question multiple-choice quiz based on Chapter 3 of the PDF. Don't give me the answers until I try to answer them."

3. Grounding Your Knowledge with Web Search

Large Language Models (LLMs) can sometimes "hallucinate" (make things up) or rely on outdated training data. To fix this, Gemini CLI has a built-in Google Search tool (often referred to as "Grounding").

This is crucial when you are learning a new technology that came out yesterday.

Example: Learning a New Framework
If you ask standard AI about the very latest version of a library, it might give you old code.

The Prompt:

"I want to use the new features in React 19. Search the web for the official React 19 release notes and documentation. Then, explain the top 3 breaking changes and provide a code example for each."

Why this builds authority:
By ensuring the /google tool (or web search capability) is enabled in your /settings, you are proving that your code is up-to-date and fact-checked against the real world.

Conclusion: The "All-in-One" Developer

We have come a long way in this series.

Installation & Basics: We learned to navigate the CLI.
Workflow Automation: We connected to extensions, workspace and analyzed data.
Mastery: We used Extensions like NanoBanana for creativity and transformed PDFs into interactive learning materials.

The Gemini CLI isn't just a tool; it's a layer of intelligence over your entire operating system. It allows you to build faster, learn quicker, and create more—all from the comfort of your terminal.

Now, it’s your turn.
Download the CLI, install an extension, and build something amazing. Don't forget to share your creations!

Special thanks to the DeepLearning.AI course "Gemini CLI" for the inspiration for this blogpost.

@leslysandra

How to get started with Gemini CLI :)

leslysandra — Mon, 09 Feb 2026 17:04:49 +0000

How to Get Started and Build with Gemini CLI (Powered by Gemini 3 Flash)

leslysandra ・ Feb 9

#ai #cli #gemini #tutorial

Part 2: Supercharging Your Workflow with Gemini CLI

leslysandra — Mon, 09 Feb 2026 16:54:35 +0000

In Part 1, we covered how to install Gemini CLI and the basics of interacting with files using the @ symbol. Now, let’s unlock the real power of this tool.
Once you have the CLI running, you aren't limited to just chatting with text files. You can connect to databases, manage GitHub repositories, and even write directly into Google Docs.
Here are four practical ways to level up your Gemini CLI skills.

1. The Power of MCP (Model Context Protocol)

This is the most "technical" sounding part, but it is actually the most exciting.

What is MCP?
Think of the Model Context Protocol (MCP) as a "Universal USB Port" for AI.
Before MCP, if you wanted Gemini to talk to your SQL database or your Slack, you had to write complex custom code. With MCP, there is a standard way to plug these tools together.

How to Connect:
Gemini CLI acts as an MCP Client. You can run "servers" (which are just small programs that talk to your data) and Gemini can instantly interact with them.

Common MCP Servers to Try:

GitHub Server: Lets Gemini search your repos, read issues, and create pull requests.
PostgreSQL/SQLite Server: Lets Gemini run SQL queries to answer questions about your data.
Filesystem Server: Gives Gemini safe access to navigate your folders (built-in).

To get started, check the /settings command or the configuration file to add an MCP server configuration.

2. Using Extensions: The Google Docs Example

Gemini CLI allows you to install extensions to expand its capabilities beyond the terminal. A great example of this is the Google Docs integration.

Why keep your AI drafts in the terminal? You can have Gemini write them directly into a document.

How to Install Extensions:
Extensions are typically installed via npm (Node Package Manager). For example, to add Google workspace capabilities, you might look for community or official packages (always check npm search gemini-cli-extension).

Real-Life Use Case:
Imagine you have finished coding a feature and need to write documentation.

The Prompt: > "Read the code in @server.js and write a technical documentation summary. Then, create a new Google Doc named 'API Documentation' and paste the content there."
The Result: You stay in the terminal, but the work appears instantly in your Google Drive.

3. Software Development: The GitHub Workflow

This is where Gemini CLI shines for developers. By connecting Gemini to your GitHub (via MCP or extensions), you can automate the tedious parts of coding.

Implementing Features:
Instead of switching between your browser (to read the ticket) and VS Code, do it all in one place.

The Scenario: You have a bug reported in GitHub Issue #42.
The Prompt: > "Read GitHub Issue #42. Then, look at @login.py and explain why this bug is happening. Finally, suggest the code changes to fix it."

Code Reviews & PRs:
You can ask Gemini to act as a senior engineer.

The Prompt: > "I just finished writing @auth.ts. Review it for security vulnerabilities before I commit."

4. Data Analysis on the Fly

You don't need to be a Data Scientist or open Jupyter Notebooks to get quick insights. Gemini CLI can digest raw data files and give you answers.

What Data Can It Handle?

CSV Files: Excel exports, financial data.
JSON: API responses, configuration files.
Log Files: Server error logs (.txt, .log).

Example: Analyzing Sales Data
Let’s say you have a file called q1_sales.csv.

The Prompt: > "Analyze @q1_sales.csv. Calculate the total revenue for March. Also, tell me which product category had the highest growth percentage compared to February."

Why this is powerful:
Under the hood, Gemini isn't just "guessing" the numbers. It can actually write and execute a small Python script to calculate the math precisely, then show you the result. It combines the reasoning of an LLM with the precision of a calculator.

Final Thoughts

The Gemini CLI transforms your terminal from a simple command prompt into an intelligent workspace. Whether you are fixing bugs on GitHub, analyzing CSVs, or drafting docs, the goal is the same: keep your hands on the keyboard and stay in the flow.

Have you tried connecting an MCP server yet? Let me know in the comments what you’ve built!

Credits: Concepts and structure inspired by DeepLearning.AI Course: Gemini CLI.

How to Get Started and Build with Gemini CLI (Powered by Gemini 3 Flash)

leslysandra — Mon, 09 Feb 2026 16:17:09 +0000

By Lesly Zerna / @leslysandra

As developers, we are constantly looking for tools that speed up our workflow without breaking our flow state. Recently, Google made a massive splash in the open-source community by updating the Gemini CLI with their latest model, Gemini 3 Flash.

If you are tired of copy-pasting code between your browser and your IDE, or if you want to see what a true "AI Agent" looks like in your terminal, this guide is for you.

Note: Many of the concepts and examples in this post were inspired by the excellent [Insert Name of Course/Instructor Here], which I highly recommend checking out.

What is Gemini CLI?

In simple terms, Gemini CLI is a terminal application that lets you chat with Google’s Gemini AI directly from your command line.

But it is more than just a chatbot. It is an open-source AI agent powered by Gemini.

When you use ChatGPT or the Gemini web interface, you are in a "sandbox"—the AI cannot see your files or run commands unless you upload them. Gemini CLI breaks that wall. It lives inside your environment, meaning it can understand your project structure, read your code directly, and help you build faster.

Why is the "Gemini 3 Flash" update important?
Gemini 3 Flash is optimized for speed and low latency. When you are using an AI Agent that needs to perform multiple steps (like "read this file," then "analyze it," then "write a test"), speed is critical. Flash makes the CLI feel snappy and responsive.

Under the Hood: How Gemini CLI Works

You might be wondering, "How does a text box in my terminal know how to run code?"

Gemini CLI uses a concept called the ReAct Loop (Reason + Act). Here is the simple explanation of what happens when you type a command:

Thought: You ask a question (e.g., "Why is my build failing?"). The AI analyzes your request.
Tool Use: Instead of just guessing, the AI sees it has "tools" available—like reading a file or running a shell command. It decides, "I should run the build command to see the error."
Observation: The CLI runs the command, captures the output (the error message), and feeds it back to the AI.
Answer: The AI reads the error and gives you the specific fix.

This "Loop" allows the CLI to act like a real pair programmer rather than just a text generator.

Why Use the CLI? (Browser vs. Terminal)

Working from the browser is great for general questions, but for building software, the Command Line Interface (CLI) is superior. Here is why:

Direct File System Access: You don't need to copy-paste code. You can simply say, "Refactor the utils.py file," and the CLI can read it and propose changes directly.
Context Awareness: The CLI knows where it is. It understands your current working directory and the files inside it.
Automation & Scripting: You can pipe output from other commands into Gemini. For example: cat logs.txt | gemini "Find the critical error".
Built-in Tools: Gemini CLI comes battery-included with tools for:
- File System: Read, write, and list files.
- Web: Fetch URLs and search Google (grounding your code in real-time info).
- Shell: Execute terminal commands safely.
Customization & Extensions: Because it is open source, you can extend it. It supports the Model Context Protocol (MCP), allowing you to build custom tools that connect to your database or internal APIs.

Real-Life Examples and Ideas to Build

Here are a few ways you can start using Gemini CLI today to boost your productivity.

1. The "Smart" Code Reviewer

Instead of manually checking your code for style issues, use Gemini CLI to review it before you push.

Command:

gemini "Review main.py for potential bugs and clean code practices. Output the suggestions as a list."

Why it works: The CLI reads the file directly and uses Gemini’s logic to find edge cases you might have missed.

2. Instant Data Analyst

Imagine you have a messy CSV file or a log file and you need quick insights.

Scenario: You have a file called server_logs.csv.
Command:

gemini "Read server_logs.csv and tell me which IP address appears the most frequently. Then, use grep to count exactly how many times it appears."

Why it works: The agent combines its ability to write code (to analyze the CSV) with system tools (like grep) to verify the data.

3. Rapid Prototyping

Need to scaffold a new feature?

Command:

gemini "Create a new folder called 'blog-app'. Inside it, create an index.html file with a basic responsive layout and a style.css file with a dark mode theme."

Result: The CLI actually creates the folder and writes the files for you. You are ready to start coding immediately.

How to Get Started: Installation

Ready to try it? Installing Gemini CLI is straightforward. You will need Node.js installed on your machine.

(Based on the official documentation at geminicli.com)

Step 1: Open your terminal.

Step 2: Run the install command.

npm install -g @google/gemini-cli@latest

Step 3: Authenticate.
You can start the tool by simply typing:

gemini

On your first run, it will ask you to authenticate. You can usually log in directly with your Google account, which gives you a generous free tier to start experimenting.

Step 4: Enable Gemini 3 Flash.
Once inside the CLI, you want to make sure you are using the latest model.
Run this command inside the tool:

/settings

Ensure "Preview Features" is toggled to True (if required) or use /model to select the Gemini 3 Flash model for the best balance of speed and intelligence.

Conclusion

The shift from chat-in-browser to agent-in-terminal is a huge leap for developer productivity. With Gemini 3 Flash now powering the Gemini CLI, we have a tool that is fast enough to keep up with our thoughts and smart enough to handle complex tasks.

Give it a try, explore the open source code, and let me know what you build!

Special thanks to [Insert Course Name] for the inspiration on these use cases.

How to Get Started and Build with Gemini CLI (Powered by Gemini 3 Flash)

leslysandra — Sun, 01 Feb 2026 02:58:59 +0000

By Lesly Zerna / @leslysandra

As developers, we are constantly looking for tools that speed up our workflow without breaking our flow state. Last June 2025, Google made a massive splash in the open-source community by releasing the Gemini CLI and in December 2025, by updating with their latest model, Gemini 3 Flash.

If you are tired of copy-pasting code between your browser and your IDE, or if you want to see what a true "AI Agent" looks like in your terminal, this guide is for you :)

Note: Many of the concepts and examples in this post were inspired by this Gemini CLI course by DeepLearning.AI, which I highly recommend checking out, as well as checking the official Gemini CLI documentation as well as Google for devs blog.

What is Gemini CLI?

In simple terms, Gemini CLI is a terminal application that lets you chat with Google’s Gemini AI directly from your command line.

But it is more than just a chatbot. It is an open-source AI agent powered by Gemini.

Why Use the CLI? (Browser vs. Terminal)

Working from the browser is great for general questions, but for building software, the Command Line Interface (CLI) is superior. Here is why:

Direct File System Access: You don't need to copy-paste code. You can simply say, "Refactor the utils.py file," and the CLI can read it and propose changes directly.
Context Awareness: The CLI knows where it is. It understands your current working directory and the files inside it.
Automation & Scripting: You can pipe output from other commands into Gemini. For example: cat logs.txt | gemini "Find the critical error".
Built-in Tools: Gemini CLI comes battery-included with tools such as:
- File System: Read, write, and list files.
- Web: Fetch URLs and search Google (grounding your code in real-time info).
- Shell: Execute terminal commands safely.
Customization & Extensions: Because it is open source, you can extend it. It supports the Model Context Protocol (MCP), allowing you to build custom tools that connect to your database or internal APIs.

Real-Life Examples and Ideas to Build

Here are a few ways you can start using Gemini CLI today to boost your productivity.

1. The "Smart" Code Reviewer

Instead of manually checking your code for style issues, use Gemini CLI to review it before you push.

Command:

gemini "Review @main.py for potential bugs and clean code practices. Output the suggestions as a list."

Why it works: The CLI reads the file directly and uses Gemini’s logic to find edge cases you might have missed.

2. Instant Data Analyst

Imagine you have a messy CSV file or a log file and you need quick insights.

Scenario: You have a file called server_logs.csv.
Command:

gemini "Read @server_logs.csv and tell me which IP address appears the most frequently. Then, use grep to count exactly how many times it appears."

Why it works: The agent combines its ability to write code (to analyze the CSV) with system tools (like grep) to verify the data.

3. Rapid Prototyping

Need to scaffold a new feature?

Command:

gemini "Create a new folder called 'blog-app'. Inside it, create an index.html file with a basic responsive layout and a style.css file with a dark mode theme."

Result: The CLI actually creates the folder and writes the files for you. You are ready to start coding immediately.

How to Get Started: Installation

Ready to try it? Installing Gemini CLI is straightforward. You will need Node.js installed on your machine.

(More details, see the official documentation at geminicli.com)

Step 1: Open your terminal.

Step 2: Run the install command.

npm install -g @google/gemini-cli@latest

Step 3: Authenticate.
You can start the tool by simply typing:

gemini

On your first run, it will ask you to authenticate. You can usually log in directly with your Google account, which gives you a generous free tier to start experimenting.

And once it is installed you can see it running in your terminal:

Step 4: Enable the Latest Features (Crucial Step!)
To use the powerful Gemini 3 Flash model, you need to enable preview features.

Type /settings in the CLI.
Look for "Preview Features".
Set this to "True". This ensures you are running on the latest, fastest, and most capable models available.

Under the Hood: How Gemini CLI Works

You might be wondering, "How does a text box in my terminal know how to run code?"

Gemini CLI uses a concept called the ReAct Loop (Reason + Act). Here is the simple explanation of what happens when you type a command:

Thought: You ask a question (e.g., "Why is my build failing?"). The AI analyzes your request.
Tool Use: Instead of just guessing, the AI sees it has "tools" available—like reading a file or running a shell command. It decides, "I should run the build command to see the error."
Observation: The CLI runs the command, captures the output (the error message), and feeds it back to the AI.
Answer: The AI reads the error and gives you the specific fix.

This "Loop" allows the CLI to act like a real pair programmer rather than just a text generator.

Navigating the Terminal: Essential Commands

Once you have installed Gemini CLI, you aren't just typing into a void. There are specific commands to help you control the agent.

/help: The most important command. Use this to see what the agent can do and how to interact with it.
/settings: Use this to explore your setup. This is where you configure your Assistant settings and change the Mode.
/docs: Opens the documentation if you need to read up on advanced features.

How to Reference Your Files

This is the superpower of the CLI. You don't need to copy-paste code. To ask Gemini about a specific file, simply use the @ symbol.

Example:

"Can you explain the logic inside @main.py and suggest improvements?"

The agent will read that specific file and base its answer on the code inside it.

Understanding Context and `GEMINI.md`

What is Context?
Context is simply a collection of information that the AI agent uses to understand your specific request. It’s the "background knowledge" the AI needs so you don't have to repeat yourself.

The Magic of `GEMINI.md`

You can teach the CLI about your project by creating a special file called GEMINI.md. Think of this as a "ReadMe for the AI."

If you place a GEMINI.md file in your folder, the CLI automatically reads it to understand your project rules, coding style, or architecture. You can place this file in:

The Global Directory: For rules that apply to all your projects.
The Current Working Folder: For project-specific rules.
Subdirectories: For rules specific to that module.

Managing Memory

You can verify what the AI currently "knows" or add new things to its memory manually using these commands:

Check Context:
```
/memory show
```
This will list everything currently in the agent's context.

Add Context Manually:

/memory add "Remember that we are using Python 3.11 for this project"

Or you can point it to a specific context file:

/memory add path/to/another/gemini.md

Already excited about the topic? This is just the intro, we'll explore more about CLI Extensions, uses for Software Development, Data Analysis, MCP and more in the coming blogs!

Conclusion (This first part!)

The shift from chat-in-browser to agent-in-terminal is a huge leap for developer productivity. With Gemini 3 Flash now powering the Gemini CLI, and the ability to customize Context using GEMINI.md, we have a tool that is fast enough to keep up with our thoughts and smart enough to handle complex tasks.

Give it a try, explore the open source code, and let me know what you build!

More blogs coming up soon! Subscribe and stay tuned!, Lesly

How to Get Started and Build with Gemini CLI (Powered by Gemini 3 Flash)

leslysandra — Sun, 01 Feb 2026 02:58:59 +0000

By Lesly Zerna / @leslysandra

If you are tired of copy-pasting code between your browser and your IDE, or if you want to see what a true "AI Agent" looks like in your terminal, this guide is for you :)

What is Gemini CLI?

In simple terms, Gemini CLI is a terminal application that lets you chat with Google’s Gemini AI directly from your command line.

But it is more than just a chatbot. It is an open-source AI agent powered by Gemini.

Why Use the CLI? (Browser vs. Terminal)

Working from the browser is great for general questions, but for building software, the Command Line Interface (CLI) is superior. Here is why:

Direct File System Access: You don't need to copy-paste code. You can simply say, "Refactor the utils.py file," and the CLI can read it and propose changes directly.
Context Awareness: The CLI knows where it is. It understands your current working directory and the files inside it.
Automation & Scripting: You can pipe output from other commands into Gemini. For example: cat logs.txt | gemini "Find the critical error".
Built-in Tools: Gemini CLI comes battery-included with tools such as:
- File System: Read, write, and list files.
- Web: Fetch URLs and search Google (grounding your code in real-time info).
- Shell: Execute terminal commands safely.
Customization & Extensions: Because it is open source, you can extend it. It supports the Model Context Protocol (MCP), allowing you to build custom tools that connect to your database or internal APIs.

Real-Life Examples and Ideas to Build

Here are a few ways you can start using Gemini CLI today to boost your productivity.

1. The "Smart" Code Reviewer

Instead of manually checking your code for style issues, use Gemini CLI to review it before you push.

Command:

gemini "Review main.py for potential bugs and clean code practices. Output the suggestions as a list."

Why it works: The CLI reads the file directly and uses Gemini’s logic to find edge cases you might have missed.

2. Instant Data Analyst

Imagine you have a messy CSV file or a log file and you need quick insights.

Scenario: You have a file called server_logs.csv.
Command:

gemini "Read server_logs.csv and tell me which IP address appears the most frequently. Then, use grep to count exactly how many times it appears."

Why it works: The agent combines its ability to write code (to analyze the CSV) with system tools (like grep) to verify the data.

3. Rapid Prototyping

Need to scaffold a new feature?

Command:

gemini "Create a new folder called 'blog-app'. Inside it, create an index.html file with a basic responsive layout and a style.css file with a dark mode theme."

Result: The CLI actually creates the folder and writes the files for you. You are ready to start coding immediately.

How to Get Started: Installation

Ready to try it? Installing Gemini CLI is straightforward. You will need Node.js installed on your machine.

(More details, see the official documentation at geminicli.com)

Step 1: Open your terminal.

Step 2: Run the install command.

npm install -g @google/gemini-cli@latest

Step 3: Authenticate.
You can start the tool by simply typing:

gemini

On your first run, it will ask you to authenticate. You can usually log in directly with your Google account, which gives you a generous free tier to start experimenting.

And once it is installed you can see it running in your terminal:

Step 4: Enable the Latest Features (Crucial Step!)
To use the powerful Gemini 3 Flash model, you need to enable preview features.

Type /settings in the CLI.
Look for "Preview Features".
Set this to "True". This ensures you are running on the latest, fastest, and most capable models available.

Under the Hood: How Gemini CLI Works

You might be wondering, "How does a text box in my terminal know how to run code?"

Gemini CLI uses a concept called the ReAct Loop (Reason + Act). Here is the simple explanation of what happens when you type a command:

Thought: You ask a question (e.g., "Why is my build failing?"). The AI analyzes your request.
Tool Use: Instead of just guessing, the AI sees it has "tools" available—like reading a file or running a shell command. It decides, "I should run the build command to see the error."
Observation: The CLI runs the command, captures the output (the error message), and feeds it back to the AI.
Answer: The AI reads the error and gives you the specific fix.

This "Loop" allows the CLI to act like a real pair programmer rather than just a text generator.

Navigating the Terminal: Essential Commands

Once you have installed Gemini CLI, you aren't just typing into a void. There are specific commands to help you control the agent.

/help: The most important command. Use this to see what the agent can do and how to interact with it.
/settings: Use this to explore your setup. This is where you configure your Assistant settings and change the Mode.
/docs: Opens the documentation if you need to read up on advanced features.

How to Reference Your Files

This is the superpower of the CLI. You don't need to copy-paste code. To ask Gemini about a specific file, simply use the @ symbol.

Example:

"Can you explain the logic inside @main.py and suggest improvements?"

The agent will read that specific file and base its answer on the code inside it.

Understanding Context and `GEMINI.md`

The Magic of `GEMINI.md`

You can teach the CLI about your project by creating a special file called GEMINI.md. Think of this as a "ReadMe for the AI."

If you place a GEMINI.md file in your folder, the CLI automatically reads it to understand your project rules, coding style, or architecture. You can place this file in:

The Global Directory: For rules that apply to all your projects.
The Current Working Folder: For project-specific rules.
Subdirectories: For rules specific to that module.

Managing Memory

You can verify what the AI currently "knows" or add new things to its memory manually using these commands:

Check Context:
```
/memory show
```
This will list everything currently in the agent's context.

Add Context Manually:

/memory add "Remember that we are using Python 3.11 for this project"

Or you can point it to a specific context file:

/memory add path/to/another/gemini.md

Already excited about the topic, this is the intro, we'll explore more about CLI Extensions, uses for Software Development, Data Analysis, MCP and more in the coming blogs!

Conclusion (This first part!)

Give it a try, explore the open source code, and let me know what you build!

More blogs coming up soon! Subscribe and stay tuned!

Lesly