Forem: Luis

Stop Re-Typing Terminal Commands! Boost Your Workflow with IntelliShell

Luis — Thu, 06 Nov 2025 15:03:00 +0000

Hey dev.to community! 👋

How much time do you spend re-typing the same kubectl, helm, argocd, terraform, or custom script commands every day? Switching contexts, finding resource names, managing environments... it often involves:

Running one command to get an ID or name.
Copying that output.
Pasting it into the next command.
Repeating. 😩

Aliases help, sure. k for kubectl is great, but it doesn't solve the core problem of constantly tweaking arguments or chaining commands manually.

From Repetitive Typing to Interactive Templates

This is where IntelliShell changes the game. It's a smart command-line assistant that lets you turn those repetitive commands into reusable, interactive templates.

Think of it like this: instead of typing kubectl logs -n my-namespace my-app-pod-123xyz --since 10m over and over, you save a template once:

# Bookmark this with Ctrl+B or 'intelli-shell new'
kubectl logs -n {{namespace}} {{pod}} --since {{time|5m}}

Now, when you need logs:

Hit Ctrl+Space (or your hotkey).
Type kube logs (or even just logs).
Select the template.
IntelliShell prompts you for namespace, pod, and time.

The Magic: Variables & Smart Suggestions

IntelliShell makes this powerful through a few key features:

1. Variables

Any part of your command wrapped in {{ }} becomes a placeholder. IntelliShell guides you through filling them in.

2. Intelligent History

It remembers the values you use for each variable (my-namespace, my-app-pod-123xyz). Next time, those values are suggested first.

3. Context-Aware Ranking

Suggestions are ranked based on how often you use them and your current working directory. Running terraform apply -var-file=envs/{{env}}.tfvars in /project-a/ will prioritize staging if that's what you used there most.

4. Dynamic Completions

You can even configure variables like {{pod}} to fetch suggestions live by running a background command (e.g., kubectl get pods -n <selected-namespace> -o name). No more get pods | grep my-app just to find the name!

Simplifying Multi-Step Workflows

Imagine common tasks with tools like Kubernetes, Helm, ArgoCD, Terraform, etc.:

Port Forwarding: IntelliShell remembers your common services and its ports.

kubectl port-forward -n {{namespace}} svc/{{service}} {{local_port}}:{{remote_port}}
Helm Upgrade: Easily switch releases and environments.

helm upgrade --install {{release_name}} {{chart}} -n {{namespace}} --values values-{{env}}.yaml
ArgoCD Sync: Quickly sync specific apps or branches.

argocd app sync {{app_name}} --revision {{branch|main}}
Executing in a Pod: Get a shell in the right pod without copy-pasting names.

kubectl exec -n {{namespace}} -it {{pod}} -- {{/bin/bash|sh}}
Terraform Plans/Applies: Avoid typos when targeting environments.

terraform {{plan|apply}} -var-file=envs/{{env}}.tfvars

Instead of chaining commands or digging through history, you trigger one template and fill in the blanks with smart suggestions. It drastically reduces typos and saves precious time.

Give it a Try

Ready to stop re-typing and start automating your common terminal tasks?

Check out IntelliShell on GitHub or follow the Book to get started.

Check Out Some Examples

After installing, a great way to see IntelliShell in action is to import some pre-made examples. Check out this sample Gist file for kubectl commands.

You can import them directly into your library with:

intelli-shell import --gist 137846d029efcc59468ff2c9d2098b4f/kubectl.sh

Now, try searching for kubectl commands using Ctrl+Space!

TLDR on Steroids - Meet IntelliShell

Luis — Wed, 29 Oct 2025 17:38:00 +0000

Hey dev.to community! 👋

We all love TLDR pages - those fantastic community-driven cheatsheets that give us practical command examples right when we need them. Standard TLDR clients are great for quick lookups, acting like a simplified man page. But let's be honest, how often do you find yourself:

Looking up a tldr page.
Copying an example command.
Pasting it into your terminal.
Painstakingly editing the placeholders?

That workflow isn't exactly seamless. It breaks your flow and feels clunky.

IntelliShell: Integrating TLDR into Your Workflow

That's where IntelliShell comes in. It's a command-line tool designed to be like IntelliSense for your shell. One of its core features is integrating TLDR pages directly into a more ergonomic, interactive experience.

Instead of just viewing TLDR pages, IntelliShell lets you fetch them and incorporate them into its searchable library.

# Fetch TLDR pages for common commands + your OS
intelli-shell tldr fetch

# Or fetch specific commands
intelli-shell tldr fetch -c tar -c git

Once fetched, these TLDR examples appear right alongside your personal bookmarks when you search (usually via Ctrl+Space).

Beyond Simple Lookups: The IntelliShell Advantage

This is where IntelliShell really shines compared to traditional TLDR clients:

1. Interactive Variable Replacement

TLDR examples often use placeholders like {{source_file}}. Regular clients just display these; you still have to manually replace them.

IntelliShell parses these placeholders and turns the command into an interactive template. When you select a command with variables, IntelliShell prompts you to fill them in, one by one.

2. Smart Suggestion History

Ever find yourself using the same filename or server address repeatedly? IntelliShell remembers the values you've used for each variable. The next time you use that command, your previous inputs are suggested first, saving you tons of re-typing.

3. Context-Aware Ranking

Suggestions aren't just random. IntelliShell ranks them intelligently based on:

Usage Frequency: Values you use often appear higher.
Working Directory: Values you've used in the current directory (or its parents/children) get a boost. This is incredibly useful for project-specific variables!

4. Seamless Workflow

Forget copy-pasting. With IntelliShell:

Hit Ctrl+Space (or your configured hotkey).
Type a few keywords (e.g., tar extract).
Use arrow keys to select the TLDR example (or a personal bookmark).
Hit Enter.
Fill in the variables using smart suggestions.
The final command is placed on your terminal, ready to execute.

It turns TLDR from a reference tool into an active part of your command execution workflow.

Give it a Try

If you're looking for a smoother way to use TLDR pages and manage your own command snippets, check out IntelliShell on GitHub and follow the Quick Start guide in the Book to get set up in minutes.

Let me know what you think! Does this solve a pain point for you? Any features you'd love to see?

Stop the Command-Line Grind: Boost Your Productivity with IntelliShell

Luis — Tue, 21 Oct 2025 15:17:00 +0000

Let’s be honest: how much of your day is spent re-typing the same long commands? How often do you run one command just to find an ID, then copy-paste it into the next one? Every docker ps | grep my-app, kubectl get pods -n prod, or manual copy-paste is a small interruption that kills your momentum and pulls you out of the zone.

What if your shell could anticipate your next step? What if it could turn those multi-command workflows into a single, interactive action?

That’s why I built IntelliShell, an open-source CLI tool that acts as a smart copilot for your terminal. It’s not just about remembering old commands; it’s about making your workflow faster, smarter, and more productive by eliminating repetitive tasks.

Beyond Shell History: From Recall to Reusability

You might be thinking, "I already have ctrl+r. Why do I need this?"

The key difference is philosophy:

Shell history is a reactive log of what you’ve done—typos and all.
IntelliShell is a proactive library of how you get things done efficiently.

They are complementary tools. Your history is for forensics; IntelliShell is for velocity.

Key Features to Supercharge Your Productivity

IntelliShell is packed with features designed to eliminate command-line friction.

🚀 Dynamic Command Templates: The End of Re-typing

This is the core of IntelliShell. Instead of saving static commands, you create reusable templates with {{variables}}.

# Stop recalling this...
kubectl logs -n production my-app-pod-xyz123 --tail 50

# Start building this:
kubectl logs -n {{namespace}} {{pod}} --tail {{lines}}

When you run the template, IntelliShell provides an interactive UI to fill in the variables. But here’s where it gets powerful...

💡 Smart Completions: Your Workflow on Autopilot

Why manually find the values for your variables? IntelliShell can fetch them for you in real-time. A completion is a simple shell command that runs in the background to generate suggestions for a variable.

Let’s supercharge the kubectl example:

# Create a completion to list namespaces
$ intelli-shell completion new --command kubectl namespace "kubectl get ns -o name"

# Create a completion for pods that is context-aware of the namespace
$ intelli-shell completion new --command kubectl pod "kubectl get pods {{-n {{namespace}}}} -o name"

Now, when you run kubectl logs -n {{namespace}} {{pod}}:

IntelliShell prompts for {{namespace}} and suggests kubectl get ns output.
Once you select a namespace (e.g., staging), it automatically runs the pod completion (kubectl get pods -n staging) in the background.
You are immediately presented with a list of pods from that namespace to choose from.

You’ve just turned a multi-step, copy-paste workflow into a single, fluid action.

🧠 AI-Powered

IntelliShell integrates with your favorite AI providers (OpenAI, Gemini, Ollama, etc.) to act as your command-line copilot:

Generate Commands: Can't remember the ffmpeg syntax to trim a video? Open search (ctrl+space), type trim video from 10s to 30s, and hit ctrl+i. The AI writes the command for you.
Fix Errors Instantly: A command fails with a cryptic error. Instead of heading to Google, recall the command and press ctrl+x. The AI will analyze the error and suggest a working version.
Import from Anywhere: Turn any text into a command library. Point IntelliShell at a blog post, a tutorial, or even your own shell history, and it will extract and convert commands into reusable templates.

🤝 Workspace-Aware and Team-Ready

Many commands are project-specific. With .intellishell files, you can define commands and completions that are only available when you're inside a specific repository.

Just create a .intellishell file in your project's root, commit it to Git, and your entire team gets instant access to the same set of common tasks—build scripts, deployment commands, and more. It's executable documentation that accelerates onboarding and standardizes your workflows.

Quick Start in Under a Minute

Ready to boost your productivity?

Install the binary:

# For sh-compatible shells on Linux/macOS/Windows (Bash, Zsh, Fish, Nu, Git Bash)
curl -sSf https://raw.githubusercontent.com/lasantosr/intelli-shell/main/install.sh | sh

For PowerShell and other installation methods, check out the Installation Guide.

Restart your terminal for the changes to take effect.
Bookmark your first command: Type a command you use often (e.g., git checkout {{branch}}) and hit ctrl+b.
Start searching: Clear the line, type a keyword, and hit ctrl+space.

What's Next?

This is just the beginning. IntelliShell is a highly configurable tool—you can customize everything from themes and keybindings to the search-ranking algorithms to make it truly your own.

Explore the Docs: Dive deeper into advanced features in the IntelliShell Book.
Share Your Knowledge: Have a set of commands that could help others? Use the export command to share your best templates and completions as a public GitHub Gist. It’s a great way to contribute to the community and help others level up their command-line game. Check out the Syncing and Sharing chapter for more details.
Contribute: IntelliShell is open-source. If you have an idea, find a bug, or want to contribute code, I'd love to hear from you. Check out the GitHub repository to get involved.

Give IntelliShell a try and let me know what you think. Stop re-typing and start doing!