BekahHW

Posted on Oct 1 • Originally published at blog.continue.dev

Stop Copy-Pasting Code Into ChatGPT: Build Your Own AI Assistant Instead

#ai

ChatGPT is powerful, but it's isolated. It has no idea what you're actually working on. It doesn't know your codebase, your tools, or your team's conventions. You end up repeating the same workflow over and over. Does this look familiar?

In this workflow, you end up being the bridge, manually gathering information from your tools, feeding it to ChatGPT, then taking its generic advice and figuring out how to apply it to your specific situation. This isn't amplifying your productivity. It's just adding steps.

What you really need to be more successful is a tool that:

Understands your deployments: "Why did the staging deploy fail?" and get an actual answer from Netlify
Connects code to user behavior: "How are users interacting with the search feature we shipped last week?" pulling real data from PostHog and GitHub
Proactively flags security issues: "What vulnerabilities were introduced in the last sprint?" querying Snyk directly
Takes action, not just suggests it: "Deploy the latest changes to staging" and actually trigger the deployment

This is what we call Continuous AI, when AI assistants work in your environment, with your tools, following your team's rules.
And you can build them today using Continue's cn CLI and our new cookbooks.

Cookbooks: Real Solutions

We've published three cookbooks that solve real problems developers face every day:

PostHog + GitHub Cookbook

The scenario: You shipped a new feature last week. Is anyone actually using it? Are they using it the way you expected?

Normally, you'd check PostHog, try to correlate events with the PR you merged, maybe dig through commits to remember what actually shipped. It's a lot of manual detective work.

With this agent: Ask "How are users engaging with the search improvements from last week?" Your assistant queries PostHog for relevant events, pulls the associated GitHub PRs, and gives you a complete picture—behavioral data connected to code changes.
You're not just seeing that engagement dropped. You're seeing it dropped specifically after the change that modified the search debounce timing.

Snyk: Security-First Development Cookbook

The scenario: A new CVE gets published. Do you have vulnerable dependencies? Which repos are affected? What's the remediation path?

Normally, you'd check Snyk's dashboard, look at each project individually, read the vulnerability details, then start hunting through your repos to understand the impact.

With this agent: Ask "What high-severity vulnerabilities were introduced this month?" Your assistant queries Snyk across your projects, identifies affected code, and can even suggest remediation strategies based on your codebase patterns.
Better yet, configure rules so your assistant automatically runs security checks before suggesting any dependency updates. Security becomes part of your workflow, not a separate audit step.

Netlify: Continuous Deployment Cookbook

The scenario: You're ready to ship. You need to check the last deploy status, trigger a new build, and monitor it until it's live.

Normally, you'd open Netlify's dashboard, wait for it to load, find your site, check the deploys, click the trigger button, then keep refreshing to see when it's done.

With this agent: Type cn "Deploy my latest changes to staging" Your assistant triggers the build, monitors its progress, and notifies you when it's live. All from your terminal, without ever opening a browser.

Building with cn: Your AI Assistant Lives in Your Terminal

The cn CLI runs in your terminal, where you actually work. No browser tabs, no context-switching, no copy-pasting. Just:
bashcn "Help me to improve page load times" And you're talking to an assistant that understands your environment.

It's Configurable, Not Generic

Each agent you build has:

Custom instructions: Define how your assistant thinks about problems. Want it to always consider performance? To follow TDD? To check analytics before suggesting features? Configure it once.
Enforced rules: Actual guardrails. "Always run tests before deploying to production." "Check for security vulnerabilities in every PR." Your assistant follows these rules consistently.
Secure secrets: Store API keys in the Continue Hub. Your assistant has access to PostHog, GitHub, Snyk, Netlify—whatever you need—without hardcoding credentials.
Model flexibility: Use different models for different tasks. Fast models for simple queries, powerful models for complex reasoning. You control the tradeoff between speed and capability. You can check out our recommended models for more information.
It Uses MCP: The Standard for Tool Integration The Model Context Protocol (MCP) is how your assistant connects to your tools. It's not a proprietary API or a vendor lock-in. It's an open standard.

That means:

Your assistant can connect to MCPs
You can write custom MCP servers for your internal tools
The ecosystem grows as more tools adopt the standard
It's Shareable and Versionable

Once you've built an assistant and configured it for your team's workflow, you can share it. Your entire team uses the same agent, with the same rules and access.

Need to update how the assistant handles deployments? Change the configuration once. Everyone benefits by making it part of team infrastructure.

How It Actually Works

Let's walk through building the PostHog + GitHub agent, because it illustrates the power of this approach:

Start with the Cookbook
Follow the PostHog + GitHub cookbook. It walks you through installing the necessary MCP servers, configuring access to PostHog and GitHub, and creating your first agent in the Continue Hub.You'll have a working assistant in about 10 minutes.
Test the Basic Functionality

cn "What are the top events in PostHog this week?"

Why This Matters: From Individual Productivity to Team Infrastructure

Here's what changes when you stop using ChatGPT and start building agents:

For individual developers: No more context-switching. Ask questions in your terminal and get answers that understand your actual environment.
For teams: Shared assistants that encode your conventions and standards. New developers immediately benefit from institutional knowledge.
For organizations: AI assistance that respects your security policies, follows your workflows, and integrates with your existing tools.

This isn't about having a chatbot that can write code. It's about building systems that amplify how your team works.

What You Can Build Today

These three cookbooks are just the beginning:

Product Development: Connect analytics, feature flags, and your repository. Ask "What features are underperforming?" and get answers that combine usage data with code complexity.
Security Audits: Connect vulnerability scanners, dependency checkers, and your CI/CD pipeline. Ask "Are we ready to ship?" and get a comprehensive security review.
Operational Excellence: Connect your deployment tools, monitoring systems, and incident management. Ask "What's the status of production?" and get real-time insights across your entire stack.
The pattern is the same: identify the tools you use, connect them via MCP, configure your assistant's behavior, and suddenly you're working at a different level.

Stop Feeding ChatGPT, Start Building Infrastructure

Every minute you spend copying context into ChatGPT is a minute you're not shipping code. Every time you explain your team's conventions to a generic AI, you're reinforcing that knowledge lives in your head rather than in your systems.
It's time to build better infrastructure.

Start with a cookbook today:

DEV Community