Stay in flow: Practical ways to use aichat in your terminal

I’ve been using CLI tools for most of my career, and I’m always looking for ways to reduce context-switching. When I discovered aichat, it immediately clicked for me–an AI assistant that works like a unix-style CLI tool and lives where I spend most of my day anyway. No jumping to browser tabs!

After integrating it into my workflow, I’ve compiled this list of uses that keep you in flow and make you more productive. Whether you’re debugging an issue, refactoring legacy code, or trying to understand a complex system, having AI assistance without leaving your terminal is a game-changer.

This guide will show you practical ways to integrate AI assistance into your terminal workflow without disrupting your focus.

Why aichat?

Terminal-based workflows are about efficiency and focus. Every context switch to a browser costs valuable mental energy and time. Aichat lets you harness AI assistance without disrupting your workflow.

It’s a lightweight CLI that connects to various AI models (OpenAI, Anthropic, etc.) directly from your terminal. I looked at similar tools like Bash AI (bai), but aichat stood out for its simplicity, configurability, and flexibility. BAI, for example, focuses on executing bash commands and only supports OpenAI models. BAI also lets you write your own plugins/tools and can be quite useful within that scope. Though we’ll only be looking at basic usage here, it’s worth noting that aichat has many advanced features that might be useful for more complex workflows.

Unlike web interfaces, aichat integrates seamlessly with other terminal tools via pipes and redirects–making it a true Unix-philosophy tool. As you look at the examples below, think about how you can use different inputs (files, stdin, clipboard, etc.) and outputs, or even embed the examples into larger scripts to fit your workflow.

Imagine cutting your context-switching by 50% while still having AI assistance at your fingertips–that’s what aichat enables.

And no, I have no affiliation with the aichat team. I’m just a happy user.

Quick install and setup

Installation is straightforward with your package manager of choice:

# Using Homebrew
brew install aichat

After installation, you’ll need to set up your configuration file. Here’s an example from my own setup to get you started:

# ~/.config/aichat/config.yaml
#
# see https://github.com/sigoden/aichat/blob/main/config.example.yaml

# default model
model: ollama:codeqwen:latest

clients:
- type: claude
  api_key: xxxx # your api key here
- type: openai
  api_key: xxxx # your api key here
- type: openai-compatible
  name: ollama
  api_base: http://localhost:11434/v1
  models:
    - name: deepseek-r1:7b
      max_input_tokens: 131072
      supports_reasoning: true
    - name: llama3.2:3b
      max_input_tokens: 131072
      supports_function_calling: true
    - name: codeqwen:latest
      max_input_tokens: 131072
      supports_vision: false

See more configuration and usage details in the official docs. I personally use a local ollama model as the default for most of my CLI work. I find that the best model I can comfortably run locally is often the best choice for me. Of course, I can always switch to a more powerful model when needed with the --model flag. I also feel better about about not accidentally spending a lot of money on a model that I didn’t realize I was using.

Basic usage

The basic usage of aichat is simple: provide a prompt and get a response. Even for our simple use here though, it’s useful to know a few different ways to provide input. Here are a few examples to get you started:

# Summarize a text file
aichat -f long_article.txt "Summarize this text"
# Summarize a web page using a non-default model
aichat --model openai -f https://example.com/article "Summarize this article"
# Summarize the last 100 lines of a log file
tail -n 100 /var/log/syslog | aichat "Summarize these logs."
# Summarize text from the clipboard
pbpaste | aichat "Summarize this text"

See the official site for more details on the available flags and options.

The aichat tool is capable of a lot more than is covered here. It has a REPL mode, a shell assistant, roles, functions, tools, RAG, and more. I’ll be focusing on the simple, single shot, CLI usage here. As such, some of these examples might be better suited for more advanced use cases. Below are examples of aichat’s flexibility and power in even the most basic configurations. If there is interest I’ll cover more advanced features in a future post.

Now let’s get into the practical applications!

Daily workflow helpers

Let’s start with tools that can streamline your everyday tasks, freeing up your mental bandwidth for more challenging work.

1. Automate daily standups

Automating daily standup updates can save time and ensure you don’t miss important items.

aichat -f '`git log -p --since=yesterday`' -f daily_log.md "Generate a summary of these activities suitable for a standup update."

I included my daily_log.md file and the output of git log to provide context. The daily_log.md file contains the notes I took during the day that may be relevant to my standup. I found that subtle changes in the request can lead to very different results, especially for short prompts like this. So experiment with the prompt/AI combination to get the best results. If you’re not getting the results you want, try adding more context (more detail about what you want) or changing the model.

If you work in multiple repositories, would it be worth it to write a wrapper script to gather all the relevant information before feeding it to aichat? For comprehensive standup updates, you could even include your calendar events or task tracker data. The tools for this would depend on your specific workflow and services you use, but a one-time setup could save you time every day.

The idea is to provide context like your tasks, notes, or commits from the previous day. What if you could automate more of your daily routine, freeing up time for deep work?

2. Shell script generation

Automating repetitive tasks saves time, but writing shell scripts can be tedious. Generate scripts for common tasks:

aichat "Write a bash script that backs up my PostgreSQL database, compresses it, and uploads it to S3 daily"

Be specific about your environment and any existing tools you want to leverage. What if you could quickly generate scripts for common tasks without having to remember all the details?

3. Create a commit message

Writing descriptive commit messages takes time but is crucial for team collaboration. Generate commit messages based on your changes:

git diff | aichat "Generate a concise, descriptive commit message for these changes"

Add the -U <number> flag to include more context lines in the diff output. The default is 3, but more lines may help the underlying model provide better suggestions.

You can even create a git alias to streamline this:

git config --global alias.ai-commit '!git diff --staged | aichat "Generate a commit message" | git commit -F -'

What if your commit history could become more meaningful with minimal effort, making code reviews and future debugging sessions more efficient?

4. Deal with bad commit messages

Dealing with vague or uninformative commit messages can be frustrating. Ask aichat to summarize a set of changes with a confusing commit message:

git log -p -1 | aichat "What was the intent of these changes?"

Above the commit range was just -1 for the last commit but this can be any range of commits that you want to understand. What if you could quickly grasp the intent of a commit without having to dig through all the code changes yourself?

5. Documentation generation

Documentation often falls behind because it’s time-consuming to write and update. Generate documentation for your code directly:

cat lib/parser.rb | aichat "Generate YARD documentation for this Ruby class"

Specify your preferred documentation format (YARD, RDoc, etc.) and style guidelines.

What if you wrapped this in a script like gendocs <file> that automatically updated documentation in your source file that you could review before committing?

Data and summaries

Now that we’ve tackled routine tasks, let’s explore how aichat can help make sense of the vast amounts of data we encounter daily. From logs to database queries, having an AI assistant in your terminal can transform information overload into actionable insights.

6. Natural language database queries

Remembering exact SQL syntax for a complex query can interrupt your flow. Sometimes is can help to describe what data you need in plain English:

aichat "Write a PostgreSQL query to find users who haven't logged in for 30 days but have active subscriptions"

Add context about your schema if needed:

aichat -f schema.rb "Given this schema, write an SQL query that..."

For more advanced usage, you might investigate the use of an SQL agent for aichat and execute your queries directly in your database. What if you could interact with your database more intuitively, getting exactly the data you need without wrestling with SQL syntax?

7. Analyze server logs

Analyzing server logs can be time-consuming and error-prone. Quickly extract insights from logs with:

tail -n 100 /var/log/syslog | aichat "Summarize these logs. Make special note of any errors or anomalies."

Include specific log files or patterns you’re interested in. What if you could quickly identify issues or trends in your logs without manually poring through them?

TIP: Providing longer prompts

If you find that your prompt needs to be longer than you can comfortably type on the command line, you can use a here document to provide the prompt.

For example:

aichat <<EOF
Write a PostgreSQL query to find users who haven't logged in
for 30 days but have active subscriptions
EOF

Better yet, you could put the prompt in a file and use the -f flag to provide the prompt. This is especially useful if you need to provide a lot of context for the AI to understand your request.

8. Summarize any text

Summarizing long documents, meeting notes, or web pages can help you quickly grasp key points. Summarize large files with:

aichat -f long_article.txt "Summarize this text"
aichat -f https://example.com/article "Summarize this article"
tail -n 100 /var/log/syslog | aichat "Summarize these logs."
pbpaste | aichat "Summarize this text"

Notice the different ways you can provide input to aichat for summarization. What if you could quickly understand the key points of any text without having to read the whole thing?

9. Data transformation snippets

Transforming data between formats is a common but sometimes fiddly task. The AI can help with this:

cat data.json | aichat "Convert this JSON to a CSV format with the following columns: id, name, email"

Of course, if this is a common task you could ask for a script to do the conversion:

aichat "Provide a ruby script that will convert JSON data input via stdin to CSV on stdout."

Then use that script over and over like this:

json_to_csv.rb < data.json > data.csv

Be specific about the input and output formats and any special handling requirements. What if dull data manipulation tasks could become simple one-liners rather than time-consuming manual efforts?

Code related tasks

With data challenges addressed, let’s turn to what many of us spend most of our day doing: working with code. Whether you’re trying to understand, debug, or improve your codebase, these examples show how terminal-based AI can supercharge your development workflow.

10. Code explanations on the fly

Understanding unfamiliar code or complex functions is a daily challenge for developers. Feed any code to aichat for an immediate explanation:

aichat -f complex_class.rb -f related_class.rb "Explain what this code does"

Need an explanation for a specific function or method? Just copy that method to your clipboard and run:

# On macOS
pbpaste | aichat "Explain this Ruby method"

# On Linux
xclip -o | aichat "Explain this Python function"

What if you could understand legacy code in minutes rather than hours, making maintenance tasks significantly less painful?

11. Error debugging assistant

Debugging obscure errors can be a major time sink. Pipe error messages directly to aichat:

ruby app.rb 2>&1 | aichat "What might be causing this error and how can I fix it?"

Of course, you could also copy the error message to your clipboard from a log file or other source and run:

pbpaste | aichat "What might be causing this error and how can I fix it?"

Include relevant context like the version of libraries or runtime you’re using. This is one of those things that a more integrated tool (aider, tabnine, augmentcode, etc.) will be better at, but it’s something that still comes in handy now and again. What if you could quickly identify the possible cause of an error and cut your debugging time drastically?

12. Code refactoring suggestions

Improving code quality is important but identifying refactoring opportunities can be challenging. Ask for refactoring advice on specific code:

cat app/controllers/users_controller.rb | aichat <<EOF
Suggest refactoring improvements for this controller following Ruby
best practices. Add comments explaining the improvements.
EOF

Specify what aspects you want to improve: performance, readability, maintainability, etc. What if you gathered a collection of commands like this and ran them as a script before a commit on the changed files? The best time to refactor code is when you’re already changing it. Would that make your codebase better and better over time?

13. Git workflow assistance

Git commands can be complex, especially for advanced operations. Get help with git commands:

aichat "How do I rebase my feature branch onto main and resolve conflicts?"

Describe your current situation and what you’re trying to achieve. What if you could leverage git’s advanced features more confidently and with less fear of breaking your repository?

14. API usage examples

Learning how to use a new API often requires sifting through documentation. Generate practical examples:

aichat <<EOF
Show me how to use the Ruby Net::HTTP library to make a POST request
with JSON data and handle the response
EOF

Specify your programming language and any particular aspects of the API you’re interested in. Sure, you could type that query into a search engine or web-based AI like perplexity, but what if you could stay in your terminal and not have to switch contexts?

15. Security review helper

Security issues can be subtle and easy to miss. Get a security perspective on your code:

aichat -f app/controllers/payments_controller.rb "Review this code for potential security vulnerabilities"

Focus on specific areas of concern like authentication, data validation, or injection risks. You could catch potential security issues early in development rather than in production. What if you could get a quick security review of your code before a problem appears in production?

16. Performance optimization suggestions

Performance bottlenecks aren’t always obvious but can significantly impact user experience. Get optimization advice:

pbpaste | aichat "Suggest ways to optimize this Ruby method for better performance"

Include context about your constraints and performance goals. What if your application could run faster and more efficiently with targeted optimizations?

Infrastructure assistance

Beyond application code, modern developers often need to wrangle with infrastructure configuration. These examples demonstrate how aichat can simplify complex configuration tasks without requiring you to memorize every detail.

17. Server configuration assistance

Server configurations can be complex and error-prone. Get help drafting a server setup:

aichat "Generate an nginx configuration for a Rails app with SSL and rate limiting"

Provide specifics about your environment and requirements. What if you could deploy more robust, secure configurations without having to remember all the details for each service?

18. Quick regex generation

Regular expressions are powerful but notoriously difficult to write and debug. Generate regex patterns for specific needs:

aichat <<EOF
Create a regex pattern to validate Canadian postal codes. Output a Ruby
method that uses the regex. Include an explanation of how the regex works.
EOF

This example works well (at least for the AI I use) but what if you need to supply more context? Perhaps examples of valid and invalid strings would help. You could do that like this:

aichat -f examples.txt <<EOF
Create a regex pattern to validate Canadian postal codes. Output a Ruby
method that uses the regex. Include an explanation of how the regex works.
EOF

Where examples.txt contains valid and invalid strings. But at some point, you might hit your limit on how much context you can provide in a single command or file, and it may be easier to use a chat interface to iterate more naturally toward a solution.

What if you could generate complex regex patterns quickly and accurately without having to remember all the syntax details?

19. Docker configuration help

Containerization is powerful, but composing the right Dockerfile can be challenging. Generate a first Docker configuration draft quickly:

aichat "Create a Dockerfile for a Python 3 application with Postgres and Redis"

Include specific versions and requirements for your application. My local AI not only provided a Dockerfile but also a docker-compose.yml file that I could use to run the application locally and instructions on how to use them.

General tips

Across all these examples, you’ve seen how aichat can keep you in flow while tackling diverse technical challenges. Here are some additional tips to help you get the most out of this tool:

• Not all tasks will be best suited to your default model. Use the --model flag to specify a better suited model for better or more cost-effective results.
• Be aware of the advanced features and capabilities of aichat. Even if you don’t use them now, it’s good to know what’s possible as your needs evolve.

Conclusion

• After weeks of using aichat, I’m convinced it’s the most efficient way to integrate AI into a CLI workflow. Browser-based AI tools simply can’t match the seamless terminal integration, and tools that are aware of your entire codebase (aider) are often not well-suited for CLI or scripting tasks.
• If you value your focus and hate context-switching, try aichat.
• In my experience, the time saved by reducing browser jumps alone pays for the effort of setting it up within the first day of use.

The beauty of aichat is that it respects your workflow as a terminal user. By keeping AI assistance in the same environment where you already work, it removes friction and helps you stay in that precious flow state we all chase. Give a try and let me know what examples you come up with!