Tag: Obsidian

Gemini Scribe Supercharged: A Faster, More Powerful Workflow Awaits

Allen HutchisonLeave a comment

It’s been a little while since I last wrote about Gemini Scribe, and that’s because I’ve been deep in the guts of the plugin, tearing things apart and putting them back together in ways that make the whole experience faster, smoother, and just plain better.

One of the first things that pushed me back into the code was the rhythm of the interaction itself. Every time I typed a prompt and hit enter, I found myself waiting—watching the spinner, watching the time pass, watching the thought in my head cool off while the AI gathered its response. It didn’t feel like a conversation. It felt like submitting a form.

That’s fixed now. As of version 2.2.0, Gemini Scribe streams responses in real-time. You see the words as they’re generated, line by line, without the long pause in between. It makes a difference. The back-and-forth becomes more fluid, more natural. It pulls you into the interaction rather than holding you at arm’s length. And once I started using it this way, I couldn’t go back.

But speed was only part of it. I also wanted more control. I’ve been using custom prompts more and more in my own workflow—not just as one-off instructions, but as reusable templates for different kinds of writing tasks. And the old prompt system, while functional, wasn’t built for that kind of use.

So I rewrote it.

Version 3.0.0 introduces a completely revamped custom prompt system. You can now create and manage your prompts right from the Command Palette. That means no more hunting through settings or copying from other notes—just hit the hotkey, type what you need, and move on. Prompts are now tracked in your chat history too, so you can always see exactly what triggered a particular response. It’s a small thing, but it brings a kind of transparency to the process that I’ve found surprisingly useful.

All of this is sitting on top of a much sturdier foundation than before. A lot of the internal work in these recent releases has been about making Gemini Scribe more stable and more integrated with the rest of the Obsidian ecosystem. Instead of relying on low-level file operations, the plugin now uses the official Obsidian APIs for everything. That shift makes it more compatible with other plugins and more resilient overall. The migration from the old system happens automatically in the background—you shouldn’t even notice it, except in the way things just work better.

There’s also a new “Advanced Settings” panel for those who like to tinker. In version 3.1.0, I added dynamic model introspection, which means Gemini Scribe now knows what the model it’s talking to is actually capable of. If you’re using a Gemini model that supports temperature or top-p adjustments, the plugin will surface those controls and tune their ranges appropriately. Defaults are shown, sliders are adjusted per-model, and you get more precise control without the guesswork.

None of these changes happened overnight. They came out of weeks of using the plugin, noticing friction, and wondering how to make things feel lighter. I’ve also spent a fair bit of time fixing bugs, adding retry logic for occasional API hiccups, and sanding off the rough edges that show up only after hours of use. This version is faster, smarter, and more comfortable to live in.

There’s still more to come. Now that the architecture is solid and the foundation is in place, I’m starting to explore ways to make Gemini Scribe even more integrated with your notes—tighter context handling, more intelligent follow-ups, and better tools for shaping long-form writing. But that’s a story for another day.

For now, if you’ve been using Gemini Scribe, update to the latest version from the community plugins tab and try out the new features. And if you’ve got ideas, feedback, or just want to follow along as things evolve, come join the conversation on GitHub. I’d love to hear what you think.

Unlocking the Future of Coding: Introducing the Gemini CLI

Allen Hutchison2 Comments

Back in April, I wrote about waiting for the true AI coding partner. I articulated a vision for an AI that transcends mere code generation, one that truly understands context, acts autonomously within our development environments, and collaborates with us iteratively. Today, I’m thrilled to announce a significant step towards that vision: the launch of the Gemini CLI.

For too long, AI coding assistance has often felt like a disconnected assistant. While dedicated AI-powered IDEs like Cursor have made great strides, the common experience still involves copy-pasting code into a separate interface or breaking flow to get suggestions. This breaks flow, loses context, and frankly, isn’t how truly collaborative partners work. We need an AI that lives where we live—in the terminal, within our projects, and deeply integrated into our workflow.

This is precisely what the Gemini CLI sets out to achieve. It’s not just a fancy chatbot for your command line; it’s an experimental interface designed to bring the power of Gemini directly into your development loop, enabling intelligent, contextual, and actionable AI assistance.

It’s for this very reason that I’ve been quite heads-down over the last few months, working with a super talented team to bring this application to life. It has genuinely been one of my most fun experiences at Google in the 20+ years that I’ve been here, and I feel incredibly fortunate to have had the chance to collaborate with such brilliant people across the company.

The Power of Small Tools, Amplified by AI

In May, I explored the concept of small tools, big ideas. The premise was simple: complex problems are often best tackled by composing many small, powerful, and specialized tools. This philosophy is at the very heart of the Gemini CLI’s design.

Instead of a monolithic AI trying to do everything at once, the Gemini CLI empowers Gemini with a suite of familiar command-line tools. Imagine an AI that can:

  • Read and Write Files: Using read_file and write_file, it can inspect your codebase, understand existing logic, and propose modifications directly to your files.
  • Navigate Your Project: With list_directory and grep, it can explore your project structure, locate relevant files, or find specific patterns across your repository, just like you would.
  • Execute Shell Commands: The run_shell_command tool allows Gemini to execute commands, build your project, run tests, or even interact with external services, providing real-time feedback.
  • Search the Web: Need to look up an API, debug an error message, or find best practices? The google_web_search tool lets Gemini leverage the vastness of the internet to inform its responses and actions.
  • Edit with Precision: Beyond simple file writes, the edit_file tool allows for granular, diff-based modifications, ensuring changes are precise and reviewable.

This approach means Gemini isn’t guessing; it’s acting. It’s using the same building blocks you use every day, but with its powerful reasoning capabilities to orchestrate them towards your goals.

A Truly Contextual and Collaborative Partner

The Gemini CLI maintains a persistent session, remembering your conversation history, the files it has examined, and the results of previous tool executions. This “conversational memory” and contextual understanding are critical. It allows for a natural, iterative back-and-forth, where the AI builds on prior interactions and its understanding of your project state.

You can ask Gemini to:

  • “Find all JavaScript files in this directory that import React.” (Leveraging list_directory and grep)
  • “Refactor this component to use hooks.” (Involving read_file, edit_file, and potentially run_shell_command to run tests).
  • “What’s the best way to implement X in Python given these files?” (Using read_file to understand your existing code and google_web_search for best practices).

The workflow is truly interactive. Gemini proposes actions, and you have the power to approve them or guide it further. This human-in-the-loop design ensures you’re always in control, fostering a collaborative partnership rather than a black-box operation.

Built by Gemini CLI, For Everyone

It’s particularly exciting to share that this project was started by a small and scrappy team, and we leveraged Gemini CLI itself to help write Gemini CLI. Many of us now work almost exclusively within Gemini CLI, often using our IDEs only for viewing diffs.

And while its origins are in coding, Gemini CLI is incredibly versatile for many tasks outside of traditional development. Personally, I love using it to manage my home lab, to bulk rename and reformat files for my podcast project, and to generally act as a seamless go-between for anything complicated in GitHub. Increasingly, I’ve also been using Gemini CLI with Obsidian to understand and extract insights from my vault. With over 9000 files in my work vault alone, Gemini CLI lets me ask questions of the entire vault and even make large refactoring-style changes across the entire thing.

Beyond Today: Extensibility

One of the most exciting aspects of the Gemini CLI, and a direct nod to the “small tools, big ideas” philosophy, is its extensibility. The underlying architecture allows developers to define custom tools. This means you can teach Gemini to interact with your specific internal systems, proprietary APIs, or niche development tools. The possibilities are endless, transforming Gemini into an AI assistant perfectly tailored to your unique development environment.

Get Started Today

The Gemini CLI represents a significant leap forward in bringing intelligent AI assistance directly to where developers work most effectively: the command line. It’s a practical realization of the “true AI coding partner” vision, built on the principle that small, well-designed tools can achieve big ideas when orchestrated by a powerful intelligence.

Ready to try it out? Head over to the Gemini CLI GitHub repository to get started. Explore the commands, experiment with its capabilities, and let’s shape the future of AI-powered development together.

I’m incredibly excited about what this means for developer productivity and the evolving role of AI in our daily coding lives. Let me know what you build with it!

How Throwaway AI Experiments Lead to Better Code

Allen HutchisonLeave a comment

Over the past few months, I’ve accidentally discovered a new rhythm when coding with AI—and it has reshaped my approach significantly. It wasn’t something I planned or found in a manual. Instead, it emerged naturally through my experiments as I kept noticing consistent patterns whenever I used AI models to build new features. What started as casual exploration has evolved into a trusted process: vibe, vibe again, and then build. Each step plays a distinct role, and together they’ve transformed how I move from a rough idea to functional software.

I first noticed this pattern while developing new features for Gemini Scribe, my Obsidian plugin. I was exploring ways to visualize the file context tree for an upcoming update. Out of curiosity, I gave Cursor an open brief—virtually no guidance from me at all. I simply wanted to see how the model would respond when left entirely to its own devices. I wasn’t disappointed. The model produced a surprisingly creative user interface and intriguing visualization approaches. The first visualization was a modal dialogue showing all files in the tree with a simple hierarchy. It wasn’t ready to ship, but I vividly remember feeling genuine excitement at the unexpected creativity the model demonstrated. The wiring was messy, and there were integration gaps, but it sparked ideas I wouldn’t have reached on my own.

Encouraged by this, I initiated a second round—this time with more structure. I took insights from the initial attempt and guided the model with clearer prompts and a deliberate breakdown of the problem. Again, the model delivered: this time, a new panel on the right-hand side that displayed the hierarchy and allowed users to click directly to any note included in the file context. This feature was genuinely intriguing, closely aligning with the functional design I envisioned. Between these two experiments, I gathered valuable insights on shaping the feature, making it more useful, and improving my future interactions with the model.

These experiences have crystalized into the three phases of my workflow:

  • Max vibe: Completely open-ended exploration to find creative possibilities.
  • Refined vibe: Targeted experimentation guided by learnings from the first round.
  • Build: Structured, focused development leveraging accumulated insights.

The first step—”max vibe and throw away”—is about unleashing the model’s creativity with maximum freedom. No constraints, no polish, just pure experimentation. It’s a discovery phase, surfacing both clever ideas and beautiful disasters. I spend roughly an hour here, take notes, then discard the output entirely. This early output is for exploration, not production.

Next comes “vibe with more detail and throw away again.” Equipped with insights from the initial exploration, I return to the model with a detailed plan, breaking the project into smaller, clearer steps. It’s still exploratory but more refined. This output remains disposable, maintaining fluidity in my thinking and preventing premature attachment to early drafts.

Only after these two rounds do I transition into production mode. At this point, experimentation gives way to deliberate building. Using my notes, I craft precise prompts and break the project into clear, manageable tasks. By now, the route forward is clear and defined. The resulting code, refined and polished, makes it to production, enriched by earlier explorations.

Interestingly, the realization of this workflow was born out of initial frustration. The first time I tried solely prompting for a specific feature set, my codebase became so tangled and problematic that I gave up on fixing it and threw it away entirely. That sense of frustration was pivotal—it highlighted how valuable it is to assume the first two tries would be disposable experiments rather than final products.

Stepping back, this workflow feels more like a structured series of experiments rather than a partnership or conversation. While I appreciate the creative input from AI models, I don’t yet see this approach as the true AI coding partner I envision. Instead, these models currently serve as tools that help me explore possibilities, challenge assumptions, and provide fresh perspectives. I discard many branches along the way, but the journey itself remains immensely valuable.

AI isn’t just writing code—it’s changing how I approach problems and explore solutions. The journey has become as valuable as the destination.

If you’ve been experimenting with AI in your projects, I’d love to hear about your rhythm and discoveries. Have you found your own version of “vibe and build”? Drop me a note—I’d love to learn how others navigate this fascinating new landscape.

Gemini Scribe Update: Let’s Talk About How Your Chat History is Now Supercharged!

Allen HutchisonLeave a comment

Hey everyone! If you’re using the Gemini Scribe plugin for Obsidian, you’re already experiencing the power of having Google’s Gemini AI right inside your notes. It’s a fantastic way to boost your note-taking and content creation. And guess what? I’ve just rolled out a major update that makes things even better!

Major Changes: A New Way to Store Your Chat History

The biggest change in this update is how Gemini Scribe handles your chat history. I’ve moved away from storing it in a database and switched to using Markdown files instead. This means your chat history now lives right alongside your notes, making your data more portable and easier to back up. I’m also introducing a new system where each note’s chat history is stored in its own separate file within the gemini-scribe folder, which will keep your Obsidian vault nice and tidy. These history files are automatically linked to the notes they came from, providing better context and making navigating your information a breeze.

Cool New Features and Improvements:

Don’t worry about a thing! The plugin will automatically move your existing chat history from the old database to the new Markdown files. This happens behind the scenes, requires no effort from you, and ensures that none of your existing chat history is lost in the process. I’ve also added a couple of new commands to give you more control: If you ever need to, you can manually trigger the migration of your chat history with the “Migrate Database History to Markdown” command. Once you’ve confirmed that everything has been migrated successfully, you can use the “Clear Old Database History” command to safely remove the old database.

I’ve also made some technical improvements to make everything run more smoothly, including improved history file management, automatic cleanup of orphaned history files, more robust history file naming, and better error handling and recovery. I want this update to be as seamless as possible for you. You’ll get clear notifications about the migration status, so you’ll always know what’s going on. If, for some reason, the automatic migration doesn’t work, you have the option to do it manually. And you can verify that everything has been migrated correctly before you clear out the old database.

I’ve also taken care to ensure backward compatibility: Your old database data will stick around until you tell me to remove it. If the automatic migration doesn’t work, you can always use the manual migration option. And rest assured, all your existing chat history will be preserved during this transition. Finally, I’ve also taken care of a few pesky bugs: I’ve fixed issues with how history files are handled when you rename notes, improved error handling for history operations, and made some tweaks to better handle those rare edge cases during history migration.

A Few Important Notes:

  • This update changes how your chat history is stored.
  • The migration process is automatic and safe.
  • Please verify that your history has been properly migrated before clearing the old database.
  • The old database will be preserved until you explicitly clear it using the new command.
  • This version also includes access to the new Gemini 2.5 Pro model!

I’m excited about these changes, and I encourage you to update to the latest version of Gemini Scribe to experience the improvements firsthand. As always, I value your feedback and suggestions as I continue to make the plugin even better. Let me know what you think!

Introducing Gemini Scribe: Your AI Writing Assistant for Obsidian

Allen Hutchison2 Comments

What if you could collaborate with an AI writing partner directly within Obsidian? Imagine brainstorming ideas, refining outlines, and polishing your prose with the help of a powerful AI assistant. Meet Gemini Scribe, a new Obsidian plugin designed to bring the power of AI collaboration to your note-taking workflow. Inspired by my own experience using AI to transform my writing process, Gemini Scribe is now available in the Obsidian community plugin library. I’m excited to share this tool that makes AI collaboration an integral part of your writing journey in Obsidian.

Why Gemini Scribe?

I’ve been using AI models to write everything from presentations and blog posts to technical documentation for awhile now. But a pivotal moment came when I was recently asked to give an impromptu talk about my writing process. I decided to walk the audience through how I collaborated with an AI model to develop the very presentation I had given earlier that day. Starting with a simple idea, I showed them how the model helped me brainstorm, refine, and polish my outline, ultimately shaping the talk they had seen. The audience’s enthusiastic response was a little surprising. They saw the power of AI collaboration firsthand, and many asked how they could integrate it into their own writing workflows. That’s the driving force behind Gemini Scribe. It’s designed to bring that same seamless AI collaboration directly into Obsidian, empowering you to supercharge your writing process just like I do.

Key Features of Gemini Scribe

Context-Aware AI Chat
Engage in dynamic conversations with Gemini directly within Obsidian. Gemini Scribe analyzes your current note’s content, providing contextually relevant responses and insights. This means you can ask questions, brainstorm ideas, and get writing assistance tailored specifically to the topic at hand. Imagine exploring different arguments for an essay or generating creative variations of a paragraph, all without leaving your Obsidian workflow.

Summarization Made Easy
Quickly generate concise summaries for any note in your vault. Gemini Scribe distills the core ideas of your notes into single-sentence summaries, automatically storing them in the document’s frontmatter. This makes it easier to review your notes at a glance, organize your ideas, and quickly recall key information. Imagine instantly summarizing meeting notes, research articles, or even long-form blog posts, all with a single click.

Collaborative Writing Assistance
Collaborate with Gemini to enhance every stage of your writing process. Brainstorm new ideas, refine existing drafts, and even generate entire sections of text with AI-powered assistance. As you interact with Gemini, your draft can be updated automatically, streamlining your workflow and allowing you to see the changes in real-time. Whether you’re outlining a new blog post, expanding on a research paper, or polishing a creative piece, Gemini Scribe can help you overcome writer’s block, explore different perspectives, and produce high-quality content more efficiently. Imagine effortlessly expanding on bullet points, transforming outlines into prose, or receiving targeted suggestions for improving your writing style, all within your active document.

How to Get Started

  1. Install Gemini Scribe:
    • In Obsidian, go to Settings → Community Plugins and search for “Gemini Scribe.”
    • Click Install and then Enable.
  2. Set Up the Plugin:
    • Obtain your Gemini API key from Google AI Studio.
    • In Obsidian, open the Gemini Scribe plugin settings.
    • Enter your API key and configure any optional settings, such as your preferred model or summarization preferences.
  3. Start Using Gemini Scribe:
    • Open the chat interface via the command palette (Cmd/Ctrl + P) and type “Gemini Scribe: Open Chat.” This allows you to interact with the AI assistant, using your current note as context.
    • Summarize notes quickly with the “Gemini Scribe: Summarize Active File” command, also accessible via the command palette.
    • Start collaborating with Gemini to brainstorm ideas, refine drafts, and enhance your writing within your active document.

What’s Next for Gemini Scribe?

Gemini Scribe is just getting started. I’m already planning exciting new features, including:

  • Audio Note Transcription: Import audio recordings and have them automatically transcribed into your Obsidian notes. This will make it easier than ever to capture ideas on the go and integrate them into your workflow.
  • Advanced Search and Recall: Quickly find relevant information across your entire vault using AI-powered search. Imagine being able to instantly surface notes related to a specific topic, even if they don’t use the exact same keywords.
  • Intelligent Predictive Text: Get context-aware text suggestions as you type, similar to a modern IDE. This feature will help you write faster and more efficiently by predicting your next sentence based on the content of your current note and your overall writing style. This feature will go beyond the current collaborative writing assistance to provide intelligent suggestions even when you’re not actively interacting with the AI assistant.

Your feedback is invaluable in shaping the future of Gemini Scribe. Please share your thoughts on these features and any other ideas you have by joining the discussion on GitHub. I’m excited to see how Gemini Scribe evolves with your input!

Try Gemini Scribe Today

If you’re an Obsidian user looking to elevate your note-taking and writing workflow, give Gemini Scribe a try. You can find it in the Obsidian community plugin library.

Thank you for your support—I’m excited to see how Gemini Scribe transforms your creative process!