Beyond the Editor: How I'm Using Continue CLI to Automate Everything

AI can feel magical when you’re filling in a function, but when you step back and try to build a real application—with security layers, architecture, testing, or CI/CD—their usefulness drops off. The author of the reddit post isn't wrong: autocomplete isn’t enough to carry you through the complexity of actual software development.

But that framing is already outdated. AI doesn’t have to stop at the editor. With tools like Continue CLI, we’re finally seeing what happens when AI steps beyond autocomplete and into automation—triaging issues, running bash commands safely, driving workflows, and even working asynchronously when you’re not at the keyboard.

That’s the shift I want to show you.

The CLI That Actually Does Things

Last week, we launched Continue CLI (cn), which provides immediate executing bash commands. I regularly use it to open issues from the command line, especially when I can tell the agent is about to go off on a discovered bug that is not a priority during our current work.

Here it asks permission first:

cn --allow Bash(git*) # Yeah, go ahead with git stuff
cn --ask Bash(rm*) # Whoa, let me check before you delete anything

This is huge. I can pipe things through it, use it in scripts, make it part of my actual workflow:

git diff | cn -p "create issue for this error so we can solve this later, be sure to leave context on how it was found and provide helpful links"

The permission system lives in ~/.continue/permissions.yaml, so you can set it once and forget about it. Your team can even share permission configs to maintain security policies. 

My Triage Bot That Comments on Every Issue

Here's where it gets fun. I built a GitHub Action that uses my Continue review agent to automatically comment on every new issue in my contributor.info repo.

The setup is surprisingly approachable. When someone opens an issue, my workflow:

1. Reads the issue content
2. Checks my custom rules for how to categorize things
3. Generates an appropriate first response
4. Applies the right labels
5. Comments with next steps

Check out the core implementation:

The Continue team is doing something similar with their PR review workflow. I’ve even made it an app (WIP - Continue Agent) that other projects can adopt as their own.

This Is Just the Start - Async Is Next

Right now, my triage bot runs synchronously - issue comes in, bot responds. But here's what's coming next: fully async automation.

Imagine:

• PRs that fix themselves based on review comments
• Documentation that updates when you change code
• Test suites that generate missing test cases overnight
• Dependency updates that merge themselves after passing CI

The building blocks are all there. Continue's parallel tool calling means multiple operations can run simultaneously. The permission system means it's safe. The rules engine means it follows your team's standards.

Thinking Outside the Normal Box

What really excites me is how I can push this beyond what anyone expected.

Offline Development That Actually Works

I shared previously how I like to code on BART and now use Continue CLI with Ollama during their BART commute. But doing this async would assist in getting me back to watching Disney+ on the train instead. The constraint of the internet is removed if I can tell the agent to fix a bug async using cn. I look forward to sharing more on this soon.

Event-Driven Everything

Other ways to hook up Continue agents to:

• Slack notifications that trigger code reviews
• Database changes that update documentation
• Commit hooks that enforce conventions
• Browser automation for end-to-end testing

This isn't just "AI helps you code" anymore. It's "AI handles the boring stuff so you can actually code."

What This Means for How We Work

Continuous AI isn't just about having AI available - it's about AI that's always working, even when you're not.

The maturity path is clear:

1. Manual: You remember to ask AI for help sometimes
2. Automated: AI handles routine tasks with your oversight
3. Autonomous: AI completes entire workflows without intervention

Most teams are at level 1. My triage bot puts me at level 2. The async automation I'm building next? That's level 3.

Try This Yourself

Want to get started? Here's the simplest useful example:

# Install Continue CLI
npm i -g @continuedev/cli

# Create a simple automation
echo "Check for issues labeled 'bug' and summarize them" | \
  cn --allow list_issues Bash -p "Use GitHub CLI to check for bug issues"

# Or add it to your GitHub Actions (pseudo example)
- name: Auto-triage issues
  run: |
    cn --config my-rules \
       --allow Write() \
       -p "Triage this issue: gh issue 123"
# Assuming the gh cli is already installed

The real power comes when you start thinking beyond "how can AI help me code" to "what can AI do while I'm not even here."

Where This Goes Next

The roadmap is pretty clear:

• Lower intervention rates (how often humans need to correct the AI)
• More sophisticated rule engines that learn from your feedback
• Enterprise features for teams that need audit trails and compliance

But honestly? The most exciting stuff will come from developers like you pushing these tools in ways nobody expected.

My triage bot started as a "what if" experiment. Now it handles 80% of initial issue responses. The async implementation I'm building next will handle even more.

The tools are here. The question is: what are you going to automate?

Want to see the code? Check out my contributor.info implementation. Got questions? Give us feedback on the CLI discussion.