DEV Community: Anita Ihuman 🌼

How Developers Can Sync Notes and Tasks Between VS Code and Notion

Anita Ihuman 🌼 — Wed, 04 Feb 2026 16:10:08 +0000

I used to lose tasks in the most embarrassing way.
Not because I didn’t write them down, but because I wrote them everywhere. A quick TODO in a code comment. Short summary in Google Docs. A meeting note in Notion, a follow-up buried in a terminal history. By sprint review, something always slipped through.

The problem wasn’t discipline. It was fragmentation.
As a developer advocate, I spend a lot of time in VS Code. But my team lives in Notion. Every task that started in my editor had to make a second trip into a Notion board before it became real. That extra step rarely happened immediately, and when it didn’t, context was lost.

I wanted one thing: to capture notes and tasks where I work but store them in the place where my team collaborates.

I recently found out I can also integrate Notion with Continuous AI, and I will show you how to achieve this in detail in this article.

The cost of Context Switching

Switching between tools feels harmless. But it adds up.
During a typical workday, I would:

Write a meeting summary in VS Code
Switch to Notion
Recreate tasks manually
Forget half the nuance I had while writing the note

Sometimes I skipped the Notion step entirely and told myself I’d “add it later.” Later never came.
The result was predictable:

Missed follow-ups
PR reviews are delayed by “I thought someone else was handling that.”
Notes that never turned into action
I didn’t need another task app.
I needed less friction between thinking and tracking.

Why Continue and Notion works

As a developer, Continue already lives in my VS Code workflow. I used it to reason through problems and draft documentation. What I didn’t realize at first was that Continue could also talk directly to external tools like Notion.

With a simple Notion integration and an API key stored in my terminal session, Continue can:

Create Notion pages
Insert tasks into databases
Update statuses, assignees, and due dates
Do all of it using plain English prompts
No copy-paste. No tab switching. Just streamlined focus.

Setting it up

The beautiful thing is that setting it up is straightforward and only needs to happen once.

Prerequisites

To integrate Continue and Notion, you will need the following setup:

Continue CLI installed (npm i -g @continuedev/cli)
A Notion workspace with Editor (or higher) access
Node.js 18+ installed locally
Continue account with Hub access

Note: Agent usage in Continue requires credits. To use agents, create a Continue API key and store it as a secret.

Step 1: Create a Notion Integration

In your browser, sign in to Notion, go to the Integration’s page (Settings - Connections - Develop or Manage Integrations)

Click New Integration

Give your integration a name (like "Continue Integration"), select your workspace, then click Save. You will be prompted to go to the Integration configuration, click on it.
Enable:

Read, Update, and Insert under Content Capabilities
Read comments under Comment Capabilities.
Read user information, including email addresses, under User Capabilities

Make sure to copy and safely keep the Internal Integration Secret.
Additionally, in your Notion homepage, you can open any page or database you would want your integration to access.

Navigate to the Database page and select the three-dot icon in the top-right corner. Under Connections, search for your specific connection, select it, and click Confirm to complete the integration. This lets your integration read and write to those pages.

Step 2: Configure Notion key in your Environment with VS Code

Open the terminal in your VS Code and navigate to your project directory. Enter this command:


export NOTION_API_KEY="secret_xxx"

Replace “secret_xxx” with the Internal Integration Secret you copied. This makes the key available in the current session. You can save the key in a .env file for easy access, but make sure to add .env to your gitignore to keep it private.

Next, if you have a specific database (like a “Tasks” list), find its ID by opening the database in Notion and looking at the URL (it’s the long string after the last / and before ?). Then run:


export NOTION_DATABASE_ID="your_database_id"

This tells Continue which database to use if a prompt refers to “my database.”

Note: Continue will automatically use the NOTION_API_KEY you set when you run it. You don’t need to manually call the Notion API – just reference “the API key stored in this session” in your prompts.

Step 3: Link and Test Notion in Continue CLI

In the terminal (in your project directory), type cn and press Enter. This launches Continue in interactive (TUI) mode. You should see a prompt where you can type instructions.

Try a prompt, for example:

1. Fetch my Tasks database using the Notion API key stored in this terminal.
2. Create a new task named "Buy groceries" with status "To Do".

Press Enter. Continue will list the actions it plans to take (e.g., creating a new database entry) before doing them. Review and approve each action. This will create a new item in your Notion database.

Also, if you trust your prompt and want to skip confirmations, you can run a one-liner like:

cn -p --auto "1. Fetch my Tasks database. 2. Create a new task 'Write report' with status 'In Progress'."

The -p flag skips the interactive UI, and --auto auto-confirms actions.
After running your prompt, switch to Notion to confirm the changes. The new task(s) should appear in your database. You can update or query entries by running new prompts, e.g., “Find tasks due tomorrow” or “Mark task X as done.” Continue handles the details via the Notion API.

Congratulations, you can now seamlessly manage your project tasks in Notion through Continue’s CLI, all from within VS Code.

What’s Next?

At the end of the day, the value of this integration isn’t novelty; it’s alignment. Your thoughts start in the editor, your work lives in Notion, and Continue quietly connects the two without demanding extra effort. By capturing notes and tasks as they’re created, you remove the most significant source of workflow failure: delay. The result is fewer missed follow-ups, clearer ownership, and a system that works with how developers already think and write.

If you want to go further, Continue supports a wide range of example prompts and workflows you can adapt to your own setup, from task automation to documentation and planning flows. I highly recommend exploring those examples to see what’s possible and to refine prompts that fit your day-to-day work. You can find them here.

Automating the Boring Parts of Development Using Continuous AI

Anita Ihuman 🌼 — Thu, 29 Jan 2026 16:16:47 +0000

Every team has that one small, annoying chore no one talks about. It doesn’t break anything. It doesn’t threaten deadlines. It just sits there, quietly stealing minutes, breaking flow, and reminding developers that even simple work can feel messy.

For Maya’s team, that chore was cleaning up log files.
Every morning, someone had to delete yesterday’s debug logs, archive the important ones, and reset the folder so their tooling didn’t choke on old data. It took three to five minutes. Not a catastrophe, but when multiplied across a week and across a team, it became a tiny tax on everyone’s routine.

One Wednesday morning, after repeating the same set of clicks for the third day in a row, Maya muttered, “There has to be a better way to automate this process and save me time.”

The Idea that Snowballed

Later that day, Maya opened her editor, determined to automate the cleanup. She was going to build a helper script that the team could drop into /scripts and forget about.
She knew exactly what she wanted:

Delete all *.logfiles older than 24 hours
Keep files tagged as important
Compress the rest into a simple archive
Run silently unless something fails

This was the kind of task everyone always says they’ll automate someday but never do. However, this time, Maya decided to use her Continuous AI to accomplish these tasks.

Prerequisites

To follow along practically with Maya’s approach, ensure your environment is set up as follows:

Continue extension installed in your VS Code
A local or cloud LLM that can handle agent mode loaded in your Continue Extension. Check out how to load an LLM locally.
Knowledge of JavaScript and NodeJS

If you don’t have these tools configured yet the necessary or knowledge, that’s fine; you can still follow Maya’s story, which focuses more on the underlying concepts of automation and collaboration than the setup details.

Implementing the Solution with Continue.dev

Step 1: Initializing the Environment

Maya creates a repository and initializes a node project in it:

npm init --y

Then she creates a file named cleanup.js inside her new repository. This is where Maya’s script will be written.

Step 2: Utilizing Continue Agent Mode

She hit the Continue.dev extension, picked a model, selected agent mode, and typed:
“Generate a small Node.js script in cleanup.js that cleans the logs, tmp, and .cache folders safely. Add dry-run support and meaningful console output.”

Step 3: The Generated Logic

Continue responded instantly with a scaffold Maya would normally spend ten minutes writing. Then it added safeguards she hadn’t thought of, such as checking whether the directory exists, handling unreadable files gracefully, and confirming write permissions before attempting deletion.

The Script Logic: How it works

The script generated by Continue is small, but it packs a lot of convenience into a few lines. This tiny cleanup tool does one job: remove common clutter folders from your project, things like temporary files, logs, and caches. It runs safely, gives clear feedback, and supports a dry-run mode so you can preview what would happen before deleting anything. Here is a quick explanation of the code:

a. It defines what clutter to remove: The script starts by listing the folders that usually accumulate junk:

const TARGETS = ["logs", "tmp", ".cache"];

You can add or remove directories at any time—this is the “cleanup list.”

b. It checks if you want a dry run: It looks for the --dry-run flag when you run the script:

const isDryRun = process.argv.includes("--dry-run");

If --dry-runis present, nothing gets deleted.
Instead, it prints what would have been removed. This makes the script safer and beginner-friendly.

c. It tries to remove each directory safely: All deletion logic lives in one helper function:

function removeDirectory(dirPath) {
  if (!fs.existsSync(dirPath)) {
    console.log(`⏭️  Skipped: ${dirPath} (not found)`);
    return;
  }

If a folder doesn’t exist, the script skips it gracefully without throwing any errors or crashes.
d. It respects dry-run mode: Before deleting anything, the script checks:

if (isDryRun) {
  console.log(`💡 DRY RUN: Would remove ${dirPath}`);
  return;
}

This ensures you're always aware of what will happen.
e. It deletes the directory (only when safe): deletion uses Node’s modern removal function:

fs.rmSync(dirPath, { recursive: true, force: true });
console.log(`🧹 Removed: ${dirPath}`);

{ recursive: true } allows removing folders with content
{ force: true } avoids errors if files are locked or missing Everything is handled cleanly with a single command. f. Processes each target folder: The main logic loops over every folder in TARGETS:

TARGETS.forEach((target) => {
  const fullPath = path.join(process.cwd(), target);
  removeDirectory(fullPath);
});

process.cwd() ensures it cleans your current project
Each folder is resolved, then passed to the cleanup function This keeps the script small but effective.

g. Prints friendly, meaningful feedback: Each run starts and ends with simple messages:

console.log(isDryRun ? "🔍 Running in dry-run mode..." : "🧼 Running cleanup...");
console.log("✨ Done!");

Documenting the tool

The script worked perfectly, but Maya wanted the whole team to use it easily. She leveraged Continue's context-awareness to generate a README.md instantly:
“Generate a short README explaining how to run this script.”
Again, the agent produced a clean, copy-ready document with usage examples, requirements, warnings, and optional flags she could add later.

Maya pushed the update and shared the repository link in the team chat.
This script was a small win, which didn’t change the project architecture or optimize performance but removed friction and benefited everyone.

Why These Tiny Wins Matter

In reality, not every improvement has to be a grand rewrite or a flashy migration.

Developers spend far less time coding than assumed: Multiple industry studies show that only 20–30% of a developer’s day is spent writing new code; the majority goes to reviews, tooling friction, debugging, documentation, and coordination.
Interruptions are disproportionately expensive: Research summarized by Atlassian and Microsoft shows that interruptions can double the time it takes developers to complete tasks and increase defect rates. Even the smallest recurring tasks can impose mental overhead, context switching, and re-orienting, which directly reduces productivity.
Small time savings compound quickly: A 5-minute daily task equals ~2 hours per developer per month. Hence, removing short, recurring tasks quietly recovers hours of focus time per engineer over a sprint.
Lowering the automation barrier changes team culture: When automation is easy, developers stop tolerating friction and start fixing it. Continuous AI significantly reduces developer effort, enabling teams to automate by default.

In Summary

While this guide is written using a developer persona to illustrate the workflow, every step described reflects how I personally use Continue to automate repetitive development tasks and improve productivity.

A script that takes a couple of minutes to put together can save hours over time. That’s often how automation starts, small, practical helpers that quietly reduce friction. The more you practice noticing these moments and turning them into scripts, the sharper that skill becomes. Tools like Continue fit naturally into that workflow, helping you create and share as you go.

Better Docs, Less Effort: Using The Continue MCP Cookbook

Anita Ihuman 🌼 — Mon, 12 Jan 2026 11:19:27 +0000

Smarter Docs, Less Effort: The Continue MCP Cookbook Approach
Documentation work rarely fails because teams don’t know what to write. It slows down because of how it’s written and updated.

For technical writers, documentation leads, and developers alike, documentation often becomes an exercise in repetition: copying old guides, aligning structures, fixing formatting drift, and reconciling style inconsistencies across multiple docs. None of this work improves clarity for users, yet it consumes a disproportionate amount of time.

Similar to writing code, documentation often feels like a friction point among teams, especially when different developers work on the project. Common mistakes like slightly different structures, missing steps, and formatting that never quite match are bound to occur.

The Continue Docs MCP (Model Context Protocol) Cookbook changes this dynamic. By leveraging AI that is natively aware of your documentation’s structure and style, you can shift from manually improving your documentation.

The Problem: A Manual, Disconnected Workflow

Up close, most traditional documentation processes looked predictably frustrating and writers had to deal with:

Rebuilding the same structure each time:

Most technical guides follow predictable patterns (What you’ll build → prerequisites → setup → step-by-step workflow → examples → troubleshooting). Yet each new guide often starts from a blank page. Writers recreate the same headings, rewrite similar explanations, and manually ensure alignment with previous documents. Over time, even the tiniest inconsistencies in these guides compound into a fragmented documentation experience.

Switcing between too many tools.

Documentation work spanned multiple tools. A code editor for examples, a browser tab for the existing docs, another for CLI references, and another still for Markdown conventions. The challenge is not writing itself but maintaining context across tools that don’t communicate with each other.

No shared style or prompt.

Every contributor brought their own tone, their own interpretation of what a good guide should look like. Reviews became less about improving content and more about reconciling mismatched voices. Editing felt like piecing together a story written by several different authors who’d never met.

Traditional product documentation is often bogged down by rigid workflows, forcing teams to spend extra hours manually correcting the structural and style inconsistencies that inevitably creep in.

Using The Continue Docs MCP Cookbook

The Continue Docs MCP Cookbook introduces a different flow, an AI-powered Model Context Protocol (MCP) server based on Mintlify. It allows your AI assistant (via the Continue IDE extension) to read your existing documentation and use it as a live reference for everything it generates.

Instead of a generic LLM guessing what your docs should look like, the MCP server provides the assistant with the exact patterns, Markdown formats, and organizational structures used in your specific repository.
The promise is to help developers and technical writers easily update their project documentation. Instead of rebuilding the same frameworks repeatedly, they can ask the system to apply known patterns automatically.

Integration: Bringing It Into the Workflow

Prerequisites Setup

To practically follow this guide, you would need the following setup:

Continue account with Hub access
Must have read: Contributing to Continue Documentation for setup instructions (The rest of the article assumes you have read this, so start here first)
Forked the continuedev/continue repository
Node.js 20+ and Continue CLI installed

Creating a new Cookbook

Every cookbook in the Continue repository starts as a plain Markdown or MDX file in docs/guides/. To add a new cookbook, open that folder and create a new Markdown file inside (use lowercase and hyphens).


deployment-cookbook.mdx

Add the required YAML formatter. E.g.:

---
title: "Your Cookbook Title"
description: "A short description of what the guide covers."
---

This is how Mintlify renders titles, previews, and metadata.

You can write your guide using the standard cookbook pattern:

* What You’ll Build
* Prerequisites
* Setup
* Steps or Workflow
* Example Commands / Code
* Troubleshooting
* Summary

The moment you save that file, Continue’s MCP agent can read it.
Now you can let the MCP agent automatically use your cookbook. Here is where the magic happens. Once a cookbook exists, Continue can:

pull its structure on demand
reuse its headings
mirror its tone
auto-fill its boilerplate
extract code patterns or examples

So instead of rebuilding a template, you start the agent:


# From your Continue docs directory

cn --config continuedev/docs-mintlify

Type in the prompt:

“Generate a new guide using the same structure as deployment-cookbook.mdx.”

Instantly, you get a fully structured skeleton - consistent, clean, aligned with your style guide.

You can check out the Continue guides documentation for other documentation workflows with prompts, such as researching and comparing existing docs.

Results: What Changes in Practice

Faster, consistent documentation: This cookbook enforces structure automatically. The time that once went to rebuilding templates can be used in writting and improving the actual context. The Continue blog captured it best: “technically simpler but dramatically more effective.”
Lighter reviews: Because the AI handles the boilerplate and formatting, Doc Leads can focus their reviews on technical accuracy and high-level clarity rather than fixing broken Markdown links.
No more context switching: The MCP agent consolidates document retrieval, code sourcing, and pattern insertion into a single conversational workflow, eliminating the friction of switching between disconnected tools.
Lighter onboarding: New contributors can bypass dense style guides by focusing on technical intent. The agent automatically applies the correct structural and stylistic standards based on simple prompts.
Higher-quality Assurance: The system enforces consistent sectioning and updates references automatically, ensuring all output aligns with project standards without the need for manual policing during review.
Real time saved: The initial prompt already delivered half the content skeleton. After that, the work feels more like shaping than assembling.

Takeaways for Any Developer

The Continue Docs MCP Cookbook isn't a replacement for the technical writing aspect of documentation. Instead, it replaces the manual labor and repetitive overhead that slows documentation down while ensuring consistency.
Your technical expertise that answers the "why" behind a feature remains the most important element. Think of the MCP as the "customizable rules" and you, the writer, as the "navigator." The system supplies the structural guardrails, while you provide the creative spark and technical nuance.

What Next?

The Continue Docs MCP Cookbook streamlines the documentation process and helps maintain consistency across your documents. By handling repetitive structure and pulling in consistent examples, the MCP shifts the work from rebuilding templates to focusing on clear, meaningful explanations.

Also, if you’ve ever wanted to contribute to Continue’s docs, now’s the easiest time to start. With the MCP Cookbook doing the heavy lifting, all you need is your perspective and a prompt. Your perspective, your examples, and your improvements can directly shape the ecosystem, so contribute, experiment, and help make the Continue docs better for everyone

Using GitHub MCP With Continue to Review PRs and Issues 5 Faster

Anita Ihuman 🌼 — Fri, 28 Nov 2025 08:08:40 +0000

As developers embrace sophisticated AI assistants like Continuous AI, the barrier between context, collaboration, and code generation is dissolving. But how do you bridge the gap between an intelligent AI in your IDE and the complex, living ecosystem of your codebase, which often resides on GitHub?

In private repositories, you might ship a new feature in minutes, but you still have to write a detailed PR description, link related issues, and hope a busy maintainer gets to it soon. In open source, the challenge is even heavier. Maintainers are flooded with pull requests, each requiring mental context switching, security scrutiny, and style-guide checks—all of which contribute to the burnout that many in the community report. However, what if you could use your AI assistant to understand the entire conversation happening on your GitHub repository from your IDE?

In this article, we are going to integrate Continuous AI directly with GitHub using the Model Context Protocol (MCP) to intelligently triage issues, suggest PR fixes, and understand your project's history from VS Code.

What the GitHub MCP Does (and Why It Matters)

The Model Context Protocol (MCP) is an open standard that allows AI tools to interact securely and contextually with external systems. Since GitHub introduced its MCP server, it quietly changed how AI tools could interact with repositories. It’s like giving your AI assistant access to now understand your repo’s context, read issues and pull requests, and even help you generate responses or code suggestions with full context instead of generic guesses.

When you integrate this MCP with an assistant coding tool like Continuous AI, your IDE gains awareness of:

The current branch, commits, and recent pull requests
Open issues with labels, authors, and comments
Code diffs, line-by-line changes, and linked discussions

Prerequisite:

Before you dive in, make sure you have the following setup.

Install the extension. Ensure you have the Continue extension installed in your preferred IDE (VS Code or JetBrains).
Install Tools & Authenticate: Install the Continue CLI (npm i -g @continuedev/cli) and the GitHub CLI (gh). Authenticate the GitHub CLI by running gh auth login in your terminal.
A GitHub account and a repository to work with Generate GitHub Token: Create a GitHub Personal Access Token (PAT) with the necessary scopes (at least repo:read).

Step 1: Connecting Continue.dev to GitHub

To make your Continue assistant talk to GitHub repository, you need to register the GitHub MCP server. This process is a one-time setup.

Install GitHub MCP via Continue Mission Control: You can install the pre-built GitHub agent by going to the GitHub Project Manager Agent page within the Continue Mission Control interface and clicking the Install button. The listing provides a pre-configured MCP block to your agent.
Set the Secret: Head over to the settings in the Continue Hub and
- Provide your GITHUB_TOKEN to Continue Mission Control, set it in your shell environment.
- You will also need to provide an Anthropic API key. So navigate to the console and create one (subscription is required).
Select Your Config: Head over to your IDE to the Continue panel and click the config selector in your IDE’s Continue panel. You can create a new configuration file in your project's directory.

Manual Config (e.g., in .continue/config.yaml): You need to define a custom agent that includes the GitHub MCP as a tool that will handle the underlying connection. Use the following sample code and update it with your API keys and token.

# This is an example configuration file
# To learn more, see the full config.yaml reference: https://docs.continue.dev/reference
name: Example Config
version: 1.0.0
schema: v1
# Define which models can be used
# https://docs.continue.dev/customization/models
models:
 - name: my gpt-5
   provider: openai
   model: gpt-5
   apiKey: YOUR_OPENAI_API_KEY_HERE
 - uses: ollama/qwen2.5-coder-7b
 - uses: anthropic/claude-4-sonnet
   with:
     ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
# MCP Servers that Continue can access
# https://docs.continue.dev/customization/mcp-tools
mcpServers:
 - uses: anthropic/memory-mcp
    with:
     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     # OPTIONAL: You may need a host if using GitHub Enterprise
     # GITHUB_HOST: ${{ secrets.GITHUB_HOST }}

4.Sync and Code: Click “Reload config” to pull your latest settings
5.Launch the Agent: From your repo root, in the terminal, run the following command:

cn --agent continuedev/github-project-manager-agent

Now, when you enter a prompt like this: “List my open issues labeled bug and summarize priorities,” you should be able to see the list of available issues in the repository, along with a summary of the issue.

Step 2: The Developer Flow - Creating Issues and Summaries

As a developer, you can use the integrated agent to handle post-coding administrative tasks without leaving your code editor.

Use Case 1: Creating a Post-Development Issue

You finished a feature, but you noticed a low-priority item that needs to be addressed later (e.g., "The API response mapping needs type enforcement").

Prompt in Continue Chat: "Create a new GitHub issue titled 'Refactor: Add type enforcement to /api/v1/user response mapping.' Assign it the label 'enhancement' and add a brief description explaining that the current implementation is brittle."

Agent Action: The agent uses the GitHub MCP's create_issue tool. It prompts you for approval, then executes the action, returning the link to the new issue: “Successfully created Issue #3: Refactor: Add type enforcement... (https://github.com/Anita-ihuman/Woo-Landing-Template-/issues/3 )”

Use Case 2: Summarizing Code for the Commit Message/PR Description

You’ve made a large refactor. You don't want to manually scan the diff for the commit message.

Prompt in Continue Chat (after staging changes): "Analyze all staged files. Summarize the changes in a concise, bulleted list that could serve as the body of my Pull Request description. Focus on the 'why' and the new architecture."

Agent Action: Although I do not have a PR or any recent updates to this repo. However, ideally, the agent will use the diff resource (from the local workspace context) and the GitHub MCP's file context for comparison. It then returns a clean summary ready for you to copy-paste into your git commit or PR template. This is a massive time-saver for detailed documentation.

Step 3: The Maintainer Flow - Reviewing PRs and Triaging Backlogs

As a maintainer of an open source project, you can automate the initial screening and feedback loop for pull requests received to the project repository.

Use Case 3: Automated Initial PR Review

For example, let's say a new contributor submits a PR. Before you read a single line of code, you will need a quick technical assessment.

Prompt in Continue Chat: "Review Pull Request #5 on the main branch. Check for obvious security flaws (e.g., using eval() or un-sanitized input) and summarize if it adheres to our project's max-line-length rule. Post the summary as a single comment on the PR."
Agent Action:
1. The agent uses the GitHub MCP's get_pull_request_diff tool to pull the content.
2. It applies specialized Rules (custom functions defined in Continue) to scan the code for the requested patterns.
3. It uses the GitHub MCP's add_comment tool to post the findings, and you should get something like this: “ AI Review: No immediate security flaws detected. However, three files exceed the 80-character line limit. Please address these before human review.”

Use Case 4: Mass Backlog Triage

If you need to clean up a stale issue backlog by prioritizing or closing old items, you can also use the GitHub MCP we configured to handle this.

Prompt in Continue Chat: "List all open issues older than 90 days with no activity in the last 30 days. For each, draft a comment asking, 'Is this still a relevant issue? If no response in 7 days, we will close it.' Only draft the comments, do not post them automatically."
Agent Action: The agent will query GitHub MCP's get_issues tool with the specified filters (age, activity). It compiles a list and provides the draft comments for you to review and approve one by one before they are posted to GitHub.

Why Does This Matter?

According to GitHub’s 2024 Octoverse Report, developers spend nearly 40% of their coding time navigating, reviewing, or refactoring existing code. Tools like Continue use these MCPs to reduce that friction by merging context, intent, and automation.

For open source maintainers, this means fewer cognitive jumps between contexts, and for developers, it means faster reviews and higher-quality contributions. And for teams, it’s a subtle but meaningful shift toward flow-based collaboration, where context lives where you work, not in the dozen browser tabs you left open.

Best Offline AI Coding Assistant: How to Run LLMs Locally Without Internet

Anita Ihuman 🌼 — Tue, 25 Nov 2025 13:31:37 +0000

As developers, we’ve all felt that shift, AI coding assistants quietly becoming part of our workflow, helping us write cleaner code, understand new codebases faster, and move from idea to implementation with less friction. They’ve gone from “nice to have” to tools we rely on daily. But the moment the internet drops, everything stops.

This led me to explore options that I can use when I have access to the internet and even when I am offline. It turns out that the Continuous AI extension also supports this capability. Instead of depending on the cloud, it lets me load local models downloaded with tools like Ollama, LM Studio, or Hugging Face and use them directly inside VS Code. Now I can access my coding assistant offline, with features like chat, autocomplete, and agents available without interruptions.

How does it work?

Offline coding assistants like Continue.dev let you run large language models directly on your machine, giving you cloud-level intelligence without an internet connection. Instead of sending your code and prompts to a remote API, they pull the models to your device and handle all inference locally. Here’s how the process works under the hood:

Download the model locally — The assistant connects to a model source such as Hugging Face or Ollama, then downloads a compatible model (often quantized) to your machine.
Load the model into a local runtime — It uses an inference engine such as GGML, llama.cpp, or GPU-accelerated backends to load the model into your RAM or VRAM.
Run all inference on-device — When you type a prompt, Continue.dev sends it to the local runtime instead of the cloud. Your CPU or GPU handles all the computation needed to generate the following tokens.
Stream results back to your editor — The model’s responses are streamed directly to Continue.dev inside your IDE, with no network delay or external data transfer.
Stay fully offline — Because everything happens on your system, from prompt to output, you can keep coding even when offline, with full privacy and consistent performance.

Downloading LLMs with Ollama

While Continue.dev lets you use local LLMs directly inside your editor, tools like Ollama are where you actually download and run the models themselves. Ollama is an open-source platform for running large language models locally.

Install Ollama

For Windows and Mac, go to the Ollama download page, click the Download button to start your download. Once the download is finished, click on the file and click the Install button.
For Linux, run this command:

curl -fsSL https://ollama.com/install.sh | sh

After installation, the Ollama GUI should open.

Running an LLM

You can download and run a wide variety of LLMs with Ollama. To run an LLM, use the following command:

ollama run "model name"

Example:

ollama run deepseek-r1

When the download is complete, your LLM should be running, and you can interact with it directly on your terminal.
You can also open the GUI to confirm your downloaded model in the dropdown and interact with it directly without the need for an internet connection.

Check out the Ollama repository for more models, information, and commands.

Use your LLM on VSCode with Continue.dev

Install Continue Extension
Now open your VSCode, go to the extensions tab, and type “Continue” in the search bar.

Click Install. After installing, the Continue extension icon should appear. Click it to open the extension window.

Pull/Download a Model

For this article, we are using two lightweight Models recommended by Continue.dev that support chat and autocomplete modes. Run the following commands:

ollama run qwen2.5-coder:3b
ollama run qwen2.5-coder:1.5b

Run Configs

In your Continue extension window, click the settings icon and navigate to Configs, and click Local Config.

A config.yaml file will show up. Populate it with this configuration:

name: Local Assistant
version: 1.0.0
schema: v1

models:
 - name: Qwen2.5-Coder 3B
   provider: ollama
   model: qwen2.5-coder:3b
   roles:
     - chat
     - edit
     - apply

 - name: Qwen2.5-Coder 1.5B (Autocomplete)
   provider: ollama
   model: qwen2.5-coder:1.5b
   roles:
     - autocomplete

 - name: Autodetect
   provider: ollama
   model: AUTODETECT

context:
 - provider: code
 - provider: docs
 - provider: diff
 - provider: terminal
 - provider: problems
 - provider: folder
 - provider: codebase

These configurations define which models can be used and how. Check out the Continue reference docs to learn more about configurations.

Voila! You are done. You can now interact with your local LLM directly in your code editor without the need for the Internet.

Advantages of using Local LLMs

Aside from not needing internet to run, tools like the Continue extension come with more advantages for developers:

Privacy and data control — With Continue.dev running models locally, your code, logs, and prompts never leave your machine. It communicates directly with your on-device model runtime, so nothing is sent to external servers. This gives you full control over sensitive repositories, internal APIs, and proprietary logic without cloud-related security risks.
Customizability — Continue.dev lets you choose exactly which local model you want to run: Llama, Mistral, Codellama, Qwen, and more. You can swap models per project, adjust context lengths, tweak inference settings, or even fine-tune your own model and point Continue.dev to it. It adapts to your hardware and workflow instead of locking you into a single provider.
Predictable performance — Because Continue.dev operates through a local inference engine, your response time depends only on your machine, not on server load or network stability. There’s no throttling, rate-limiting, or unpredictable latency. Whether you’re refactoring a file or generating new components, the speed stays consistent.
Cost efficiency — Once you download the model and set it up with Continue.dev, you avoid ongoing API charges entirely. There are no per-token costs, monthly bills, or usage caps. You get unlimited inference, unlimited tokens, and full autonomy without burning through credits or subscriptions.

In essence, local LLMs with the use of the Continue extension offer a level of control, reliability, and security directly into your code editor. Whether you’re dealing with unstable or no internet, sensitive code, or the need for faster, more consistent performance, running models on your own machine gives you an edge.

What’s Next?

The future of offline coding assistance is here. It continues to evolve, with tools like Continue and Ollama that let developers run large language models locally in their environments without relying on the internet.
With tools like Continue, setting up local LLM support in your code editor is now easier than ever. So play around with it, run more models, sharpen your skills, and enjoy the joy of AI coding assistance even without an internet connection.

How to Prompt AI Coding Assistants for 90% Accurate Code: The Ultimate Developer Guide

Anita Ihuman 🌼 — Fri, 14 Nov 2025 13:50:25 +0000

I just needed to complete a simple task. Create a basic Express.js app, nothing fancy, just a small REST API scaffold for a project demo. So I did what any modern developer would:
I opened Continue, my AI coding assistant, inside VS Code, and typed:

Create an Express app.

Seconds later, a few lines of boilerplate code appeared like magic:

const express = require('express');

const app = express();


// Start server
app.listen(4000, () => {
  console.log('Server running on http://localhost:4000');
});

Everything looked familiar until I ran it.
Then Boom, Error!

I’d forgotten that I was using ES modules, not CommonJS. The AI didn’t know that.
I hadn’t told it.

Although it was a subtle oversight, in that moment, I realized something important: the accuracy of my coding assistant had nothing to do with its intelligence.
It had everything to do with how I talked to it.

When AI “Understands” without Understanding

Every developer who uses AI coding assistants has seen this happen: a technically incorrect yet perfectly confident answer.
That is AI hallucination: when an AI model produces incorrect, nonsensical, or fabricated information confidently, as if it were true. This is because language models predict the most statistically likely next word based on data it has been fed, rather than truly understanding the information.

So when you tell your assistant, “create an Express app”, it gives you what’s most common — not what fits your setup.
No wonder it missed the ES module part. It didn't misunderstand me. It just filled in the blanks I left empty.

Turning Point - Writing Better Prompts

After a few more “why won’t this run?” moments, I decided to treat Continue like a junior developer, not a search bar.
Instead of one vague sentence, I gave it real instructions:

Create a simple Express.js app using ES modules.
Use import instead of require.
Add routes for / and /health, and include a middleware that logs the request method and URL.
Use port 4000.

Continuous AI generated this:

import express from 'express';

const app = express();

// Middleware
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next();
});

// Routes
app.get('/', (req, res) => res.send('Hello from Continue.dev!'));
app.get('/health', (req, res) => res.json({ status: 'ok' }));

// Start server
app.listen(4000, () => {
  console.log('Server running on http://localhost:4000');
});

And this time, it ran perfectly.
No rewrites. No fixes. Just clean, working code.

Why This Works

Large language models like the ones Continue supports don’t think, they predict. The clearer your prompt, the narrower the prediction range, and the higher your accuracy.
When you give Continuous AI context, constraints, and intent, you help it eliminate wrong guesses.
In practice, it looks like this:

Prompt Element	Example	Why it matters
Context	“Using ES modules in Node.js…”	Avoids incompatible syntax
Constraints	“Only include routes / and /health”	Keeps code focused
Intent	“I just want a lightweight scaffold for testing APIs.”	Prevents over-engineering

Coding assistants like Continue also gain an edge by reading your actual codebase in VS Code, so they don't need to guess your environment if you let them see the files. That means your next prompt becomes part of a conversation rather than an isolated question.

Best Practices For High Accuracy

Generally, you should follow these guidelines to get the most accurate responses from your coding assistant:

Write Clear, Goal-oriented Prompts

Start with the problem statement (“Write a function that validates requests”)
Specify the language and framework (“in JavaScript using Joi”)
Describe constraints and expected behaviour (“must validate all requests, authorized or unauthorized”)

Provide Adequate Context

Reference related functions if needed (“use the existing database schema to check authorized or unauthorized requests”)

Break Tasks Down

Request for smaller testable parts instead of entire modules. Example: ask for “the SQL query first” before “the full Express route handler.”

Refine And Improve

If output is off, clarify what went wrong in the following prompt(“It doesn’t handle empty input; fix that”).
Each feedback loop improves accuracy significantly.

With a coding assistant like Continuous AI, you can access models configured for various roles in the Continue extension. This makes it easy to switch between chatting, autocompleting code suggestions, applying edits to a file, and more. When you describe what you want (e.g., “add authentication middleware” or “optimize this query”) and switch to the desired role, it understands your intent and acts accordingly.

Overall, AI coding assistants can only amplify your skill, they don’t replace it. Hence, when working with AI coding assistants, remember to always read and reason through the generated code before running it. The key to 90% accuracy isn’t automatic; it’s clarity, validation, and iteration.

Building a Custom MCP Server in Continue: A Step-by-Step Guide

Anita Ihuman 🌼 — Fri, 10 Oct 2025 17:03:24 +0000

Imagine you hire a world-renowned and brilliant historian who has memorized every textbook ever written up until 2023. They can tell you about any historical event in detail. However, when you ask them how many github repostory have been created in the last 5 years, or what the stock prices are or about the latest weather conditions in your city, they have absolutely no clue. Their knowledge is immense, but static.

Similarly, machine learning models are brilliant, yet isolated from real-time data. The problem is that they are often not trained on the specific information or context of the question you are asking.

For AI agents to obtain up-to-date context on a subject, they rely on Model Context Protocol (MCP) servers to interoperate with external tools and resources (SDKs, APIs, and front-end systems). In this article, we’ll discuss what MCPs are and show you a step-by-step guide on how to build your custom MCP server in TypeScript Continuous AI.

What is a Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open protocol that enables large language models (LLMs) to securely connect with external data sources, tools, and environments. Similar to design patterns like Retrieval-Augmented Generation (RAG), tool calling, and AI agents, MCPs provide more contextual data to LLMs.

MCP was developed by Anthropic and has been adopted by major industry players such as Continue, OpenAI, and others. MCP provides a standardized way for AI models to access real-time information and perform actions beyond their static training data. An MCP defines key components like tools (functions or actions an AI can execute), resources (contextual data such as files or schemas), and prompts (predefined templates guiding AI behavior).

Problem Statement:

When you ask, Continue with the current exchange rate for USD, this is what you will get.

To address this challenge, let's build a custom exchange rate MCP server that will help Continue to access live data from the exchange rate API and provide us with real-time rates for 168 world currencies in our VSCode. By the end, we should be able to get real-time data on current exchange rates for USD for different currencies. The steps in this article can be used to create any MCP server of your choice.

System Requirements and Tools

Basic knowledge of TypeScript/JavaScript
Node.js is installed on your machine (version 16+).
VS Code installed
An exchange rate API access

Step 1: Initial Setup and Environment Configuration

Let's start by setting up our development environment.

a. Create a project directory.

Open your terminal to create a new directory and initialise with NPM using the following commands:

mkdir exchaterate-mcp-server
cd exchangerate-mcp-server
npm init -y

b. Create an entry point file

Inside the new directory you created, make a src/ directory that will hold our code. Inside this folder, create a file that will serve as our entry point.

mkdir src

touch src/main.ts

c. Configure the package.json file

The MCP SDK requires JavaScript modules, so open the package.json file and add ‘"type": "module" ' to enable ES module syntax.

{
 "name": "exchangerate-mcp-server",
 "version": "1.0.0",
 "type": "module",
 "description": "",
 "main": "index.js",
 "scripts": {
   "test": "echo \"Error: no test specified\" && exit 1"
 },
 "keywords": [],
 "author": "",
 "license": "ISC",
}

d. Install dependencies

The MCP server requires two key libraries to be installed.

The MCP SDK, which will provide everything we need for server functionality
And Zod for schema validation.

npm install @modelcontextprotocol/sdk

npm install zod

This is what your config.js file should look like once both libraries are installed.

Step 2: Creating Your MCP Server in TypeScript

For the next step, we need to create the MCP server.
Open your main.ts file in VSCode and update it with the following steps to define your server.

a. Import all required modules

You will need to specify the necessary classes from the installed packages.
This sets up a new MCP server and imports McpServer and StdioServerTransport from the MCP SDK.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

import { z } from "zod";

b. Create server instance

The server handles all communication over the MCP protocol between clients (such as VS Code) and your tools. So you need to create an instance of MCPServer, specifying its name and version.

c. Define the tool

Next, we need to define the functions (or tools) that the AI agent will call.

Create a tool called “currency-live-rates”. For now, we'll use static data to ensure the basic setup is working as expected.

server.tool(
  'currency-live-rates',
  'Tool to get the live exchange rate of a base currency (static example)',
  {
    base: z.string().describe("The base currency code (e.g., USD, EUR, GBP)."),
    symbols: z.string().optional().describe("Optional comma-separated list of target currencies (e.g., GBP,JPY).")
  },
  async ({ base, symbols }) => {
    // Static mock data for demonstration
    return {
      content: [
        {
          type: "json",
          text: JSON.stringify(
            {
              success: true,
              terms: "https://exchangerate.host/terms",
              privacy: "https://exchangerate.host/privacy",
              timestamp: 1727457600,
              source: base,
              quotes: {
                [`${base}USD`]: 1.0,
                [`${base}EUR`]: 0.92,
                [`${base}GBP`]: 0.81,
                [`${base}JPY`]: 148.56
              }
            },
            null,
            2
          )
        }
      ]
    };
  }
);

What we have basically done here is:

We are registering the tool with the server using server.tool. We gave it a unique ID (currency-live-rates), a description, a parameter schema, and a callback function.
Using Zod, the parameter properties define and validate the expected input. The tool expects an object with a required string property base (the base currency code) and an optional string property symbols (a comma-separated list of target currencies).
When the tool is called, the server validates the input against the schema. If the input is valid, it calls the callback function.
The callback receives the validated parameters and then creates a static response with currency exchange rates for the specified base currency. The response includes example rates for USD, EUR, GBP, and JPY.

d. Set up transport and connection
The next step is to define how the server communicates with AI clients.

In this case, use the StdioServerTransport for communication (reading from standard input and writing to standard output) in your local development.
Then connect to the server.

const transport = new STDioServerTransport();
server.connect(transport);

Your main.ts file should look like this once that is completed.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { z } from "zod";

const server = new McpServer({
  name: "Currency Live Rates Server",
  version: "1.0.0",
});


server.tool(
  'currency-live-rates',
  'Tool to get the live exchange rate of a base currency (static example)',
  {
    base: z.string().describe("The base currency code (e.g., USD, EUR, GBP)."),
    symbols: z.string().optional().describe("Optional comma-separated list of target currencies (e.g., GBP,JPY).")
  },
  async ({ base, symbols }) => {
    // Static mock data for demonstration
    return {
      content: [
        {
          type: "json",
          text: JSON.stringify(
            {
              success: true,
              terms: "https://exchangerate.host/terms",
              privacy: "https://exchangerate.host/privacy",
              timestamp: 1727457600,
              source: base,
              quotes: {
                [`${base}USD`]: 1.0,
                [`${base}EUR`]: 0.92,
                [`${base}GBP`]: 0.81,
                [`${base}JPY`]: 148.56
              }
            },
            null,
            2
          )
        }
      ]
    };
  }
);

const transport = new StdioServerTransport();
server.connect(transport);

Step 4: Testing with MCP Inspector

For the next step, we need to confirm that what we have so far works as expected before we can input real exchange rate data.
To do this, we will utilize the MCP Inspector, a web-based tool used for testing and debugging MCP servers.

a. Run the server with inspector
Run the following command in your terminal to open the MCP inspector:

npx -y @modelcontextprotocol/inspector npx -y tsx main.ts

b. Connect and test with the inspector

The output should look like the screenshot below.

With a localhost URL for the proxy server. Click on the URL that includes the session token (avoids manual entry) to open the Inspector in your browser.

Click “Connect” in the Inspector UI.

Navigate to ‘Tools’ and click ‘List Tools’. You should see currency-live-rates.
Click on ‘currency-live-rates’ to open the tool caller.

Now, test it out by entering a base currency (e.g., USD) and optionally a list of target currencies (e.g., EUR, GBP, JPY) in the input fields, then click ‘Run Tool’.
You will get an output that shows the live exchange rates in JSON format, like this:

Once you have confirmed that it works as expected, the next step is to use actual data for our server.

Step 5: Fetching Realtime Exchange Rate Data

Now that we have confirmed our code sample works as expected, it's time to input actual data from exchangeratehost, a foreign exchange & crypto rates data solution.

a. How the Exchangeratehost API works

The Exchangeratehost API provides live updates on the exchange rate between different currencies.

You can specify the base currency (for example, USD) you want to obtain other rates against.
You can also tell it which other currencies you want to compare it with (for example, EUR, GBP, JPY).
The API then sends back a response that includes the latest rates.

We will be using the real-time exchange rates API endpoint for our MCP server. Once you have created an account, you will be assigned a personal API access key, which you can attach to our preferred API endpoint URL.
Check the Exchangeratehost API documentation for details.

b. Update main.ts file

Replace the tool example function with the following:


import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";


const server = new McpServer({
 name: "Currency Live Rates Server",
 version: "1.0.0",
});




server.tool(
 "currency-live-rates",
 "Get real-time exchange rates for a given base currency",
 {
   base: z
     .string()
     .describe("The base currency code (e.g., USD, EUR, GBP). Defaults to EUR if not provided."),
   symbols: z
     .string()
     .optional()
     .describe("Comma-separated list of target currencies (e.g., USD,GBP,JPY). Optional."),
 },
 async ({ base, symbols }) => {
   try {
     // Build the URL dynamically
     let url = `https://api.exchangerate.host/live?access_key=APIKEY`;
     if (symbols) {
       url += `&currencies=${symbols}`;
     }


     // Fetch live exchange rates
     const response = await fetch(url);
     const data = await response.json();


     if (!data.success) {
       return {
         content: [
           {
             type: "text",
             text: `Error: Could not fetch live rates for ${base}. Please check your input.`,
           },
         ],
       };
     }


     // Format output: show base + filtered rates
     const rates = Object.entries(data.quotes)
       .map(([pair, rate]) => `${pair}: ${rate}`)
       .join("\n");


     return {
       content: [
         {
           type: "text",
           text: `Real-time rates (Base: ${base})\n\n${rates}`,
         },
       ],
     };
   } catch (error: any) {
     return {
       content: [
         {
           type: "text",
           text: `Error fetching live exchange rates: ${error.message}`,
         },
       ],
     };
   }
 }
);


const transport = new StdioServerTransport();
server.connect(transport);

c. Test real data on the MCP inspector

Restart your server by stopping the running process in the terminal
In the MCP inspector, click on connect again (similar steps to before)
Run the currency-live-rates tool by entering a base currency (e.g., "USD") and optionally some target currencies (e.g., "EUR, GBP, JPY"). Your tool result should look like this:

Step 6: Setting Up MCP in Continue

Once your MCP server is running, you can connect it to a tool-enabled AI agent, allowing it to utilize your currency exchange rate capability. We are using the Continue VSCode assistant for this example.

a. Installing and Configuring Continue in VS Code

If you have not already, install the Continue. Continue is available in VS Code and JetBrains, so whichever IDE you use, you should be able to find it as an extension.

The Continue extension defaults to the left sidebar upon -installation. drand and drop the icon panel to the right sidebar.
Next, need to sign up or sign in to the Continue Hub, where you can discover, configure, and manage the models, rules, and MCP tools you need for your AI coding agent.
Once signed in, navigate this IDE dropdown and select the exact IDE you are working with.
You will be met with the option to create an organization or to use the community organisation available. I will be using the Continue Community for this example as it comes with predefine agents you need to install.

You should be redirected back to VSCode. Continue panel should have a dropdown that lists the agents you installed.

b. Create an MCP server
Now that we have set up Continue, lets create a new MCP that will help the AI agent access the real time data we need from the exchange rate API.

Navigate to the setting on the continue panel, down to the tools icon. You will see a plus button where you can add new servers.

This should take you back to the Continue hub where their are a variety of available MCP server you choose from. However, since we already created our own MCP server locally. We just need to add a configuration file that will tell Continue to access the content of our local server.

c. Create a new folder in the working directory called Continue

Create a new file within this folder called currency-mcp.yaml.
Input the following configurations into the yaml file created.

Name: MCP name
version: 0.0.1
schema: v1
mcpServers:
  - name: MCP Name
    command: npx
    args:
      - -y
      - "/Users/path/currency-mcp-server/main.ts" // change to the path your mcp code typescript code

This configuration tells the system to start an MCP server by running the TypeScript file at the given path using npx, with the -y flag to skip prompts.

d. Run the server

For the following command in your terminal to run the server.

npx -y main.ts

To confirm that everything is working as expected, check the under tools in Continue again, your MCP should be added to the list like this.

The Result?

Now that we have completed our MCP server, let's take a look at the final result.

Go to your Continue panel and make sure you're in "Agent Mode." This will tell the AI that it's okay to start reasoning and using external tools, not just its internal knowledge.

When you give continuous AI the prompt “What are the current exchange rates for USD” to test the MCP server, it will examine your question and realize it does not have live data on the currency exchange rate. However, it now has a tool called currency-live-rates that can retrieve it.
Since our tool interacts with real-time data, Continue will request permission to use your currency-live-rates tool to retrieve the data.

Instead of JSON format, Continue will now return a refined context that summarizes the list of current exchange rates for USD.

What's Next?

Building a custom MCP server is a great way to unlock the full potential of AI-assisted development in your own environment. If you are new to MCPs and want to explore, your best bet is to start experimenting with internal MCP servers tailored to your needs.
Continuous AI is open source, so you can learn more about this tool, access templates, and contribute to the ecosystem through the Continue GitHub repository. You can also connect with other builders and share ideas in the Continue Discord community

How are Different Developers Using AI Coding Assistants?

Anita Ihuman 🌼 — Tue, 30 Sep 2025 07:53:42 +0000

AI coding assistants like Continue, Codex, GitHub Copilot, Windsurf, and Devin have quickly shifted from experimental to everyday developer tools. While some still see them as nothing more than magic text/code generators or even fear they’ll replace human developers, the reality looks different. Developers aren’t just adopting and leveraging AI for quick snippets or vibe coding sessions. They’re using them for building and designing production-viable systems, coding, testing, and even documentation.

Recent industry surveys show that between 76% and 89% of developers already use these tools or plan to soon, and 94% of companies surveyed have some teams actively using AI coding assistants. Despite debates about accuracy, many find them invaluable for boosting productivity, reducing repetitive work, and shortening time-to-market.

In this article, we’ll explore how these tools are shaping the day-to-day lives of developers at every level, from startup founders to senior engineers and junior developers contributing to open source.

What Are AI Code Assistants?

AI coding assistants, otherwise known as coding companions, are tools powered by large language models (LLMs) trained on massive amounts of code and natural language (Java and Python). The difference from traditional autocomplete is the intelligence. Instead of just filling in the next word or bracket, AI assistants can understand context, spot patterns, and help solve bigger problems.

Software developers utilize AI coding to integrate AI into their workflows, achieving higher productivity and quality while also learning new concepts and insights. Most of these AI assistants are integrated into familiar environments where developers already work, such as Visual Studio Code, JetBrains IntelliJ IDEA, or even the command line.
They offer a growing set of capabilities that span the entire development workflow, such as:

Generating code snippets to match a developer’s request.
Building test cases that cover multiple scenarios.
Translating code across programming languages.
Upgrading legacy code to newer versions.
Explaining code in plain language to support learning.
Creating documentation to speed up DevOps processes.

Who Is Actually Using These Tools?

The Start-Up Founder

A lot of people have had brilliant project ideas, only for them to remain stuck in their notebooks. This is often the case for most non-technical founders. Without a clear path to execution, many great concepts simply fade away.

However, in the past years, with the prevalent use of AI models and coding assistants, it has become easier for non-technical founders to move from ideation to releasing a product MVP.
A study by Cornell University found that tools like ChatGPT, Continue, and GitHub Copilot can generate code that runs without errors about 90% of the time. This surpasses 30% to 65% of unit tests and are secure around 60% of the time. With the right prompts, these tools can be leveraged by anyone, even those with no technical background, to create code samples right in their IDE or CLI.

For instance, Mary is a non-technical founder with a brilliant idea for a new productivity app. She knows her market inside out but struggles with initially developing the source code. With a lack of funds available to her, hiring a developer is out of budget, and online tutorials are overwhelming and will take longer before the idea goes live.
Instead, Mary can turn to AI website builders like Lovable. By simply describing the app’s features, core functions, and desired outcomes, she can generate a ready-made user interface in HTML, CSS, and JavaScript. She can then take that code into her local IDE. With an AI coding assistant like Continue, which integrates directly into her development environment, Mary can refine the application further, add new features, and even deploy it seamlessly using platforms like Netlify or GitHub.

Just like that, Mary’s idea can become a real, existing project she can share with the world. Using a coding assistant like Continue allows you to build an MVP in record time. Since Continue runs on local models (on her own computer, instead of sending data to the cloud), it also keeps Mary’s original ideas safe.

Junior Developer

Real-world, legacy open-source code written in R, Python, JavaScript, or Go applications isn't like the clean, simple, controlled projects from boot camps. Maintainers aren't always available to answer every question, and getting a timely response on Stack Overflow can be time-consuming. AI coding assistants like Continue can bridge the gap by helping juniors quickly grasp a new language’s syntax or a framework’s API without drowning in endless documentation.

Take David, for example. He ran into a puzzling TypeError in his addToCart function while contributing to an open-source e-commerce project. Instead of just copy-pasting the error into Google, he asked the AI coding assistant directly in VSCode, “Why am I getting this TypeError in my addToCart function?” The AI assistant will then break down the concept of data types in JavaScript, explain why his input was invalid, and suggest a quick fix.
This will turn a frustrating roadblock into an opportunity for David to actually understand the problem, making it a good learning experience.

However, there’s a caveat. These tools don’t replace the need for a solid foundation in programming. Research by Computers in Human Behavior indicates that a student's frequent use of AI chatbots for programming tasks is associated with a negative correlation in their academic performance. These tools exist to help implement ideas and learn more quickly, but the core knowledge still needs to come from you.

The Senior Engineer

Senior engineers often face a different challenge. For them, it’s not just about learning syntax or getting started. It’s about managing complexity at scale and fast. Many engineering leaders are skeptical of AI coding tools, as they worry that these tools could weaken their team’s skills or compromise security. But here’s the thing: AI assistants are incredibly fast, and while speed is their forte, the senior engineer is well-versed in the fundamental skills. And in practice, editing and refactoring code is often quicker than writing it from scratch, which is where Continue comes in handy.

Take Sarah, a senior staff engineer at a legacy cloud platform. She can use the Continue CLI version to scan and refactor the legacy module that no one wants to touch. Based on her prompts, Continue will then identify the inefficiencies and suggest modern patterns in the terminal. Sarah can review these changes and determine if they align with her expected outcome. By deploying the AI with her team's specific models on their private cloud, she can ensure the team's sensitive intellectual property remains secure.

For Sarah, the AI didn’t replace her expertise, but rather amplified it, helping her tackle bigger problems and boosting her team’s overall output.

In Summary,

AI coding assistants are becoming everyday companions for developers at every level. Their potential impact is evidenced as Gartner projects that “90% of enterprise software engineers will utilize AI code assistants by 2028, a significant increase from less than 14% in early 2024.” Developers can now utilize AI coding assistants to automate repetitive tasks, such as creating standard blocks of code and generating routine documentation.

Ultimately, the goal of these tools is not to replace human creativity, judgment, or skill, but to free up development time, accelerate delivery, and open new paths for learning and creativity.

How to Get More Done with AI in My Local Dev Workflow: ChatGPT vs. Continue

Anita Ihuman 🌼 — Mon, 22 Sep 2025 12:46:00 +0000

When AI coding agents first started buzzing around, I was skeptical. I thought, "Cool, another bot to generate ‘Hello World’ in 50 languages." But once I started using one, my perspective completely changed.

I'd compare the experience to moving from endlessly Googling "why am I getting this error" to having a pair-programming partner in your editor, point at the bug, and say, "See that bug on line 42? This is how to fix it."

I began exploring more AI coding agents and rethinking my development workflow when I came across Continue.dev, an open-source AI agent. I wondered how it stacked up against the popular ChatGPT. In this article, I will discuss what distinguishes these two tools.

Tl;dr: Comparison of ChatGPT Vs Continue.

Feature/Aspect	ChatGPT	Continue
Where it lives	Browser (web-based)	Inside your IDE (VS Code, JetBrains)
Context awareness	None (only what you paste)	Full project view (files, dependencies, structure
Customization	Limited (prompt engineering only)	Highly customizable (choose LLM, build actions)
Learning curve	Very low (just ask questions)	Medium (requires setup + tinkering)

ChatGPT: The Generalist

You've probably used it before. ChatGPT is a conversational AI chatbot developed by OpenAI. It uses a large language model (LLM) to understand and generate text in response to user prompts and can be used for a wide range of tasks. ChatGPT is excellent for:

Brainstorming and Learning: You can ask it to explain a complex algorithm, help you understand a new programming concept, or even draft documentation.
Quick Answers: You can use it to write a quick script in a language you're not familiar with. Its massive training data makes it easy to tackle a wide variety of tasks.
Simple Debugging: You can paste in a snippet of code and ask, "Why isn't this working?" and it will usually give you an extensive explanation.

The Downsides of Using ChatGPT for Local Dev

Lost Context: When you ask a question, it gives an answer. However, it doesn’t know your actual codebase, your project structure, or how different files relate to each other. This results in vague responses to specific prompts that require depth on the project structure.
Interrupts Your Flow: Developers often struggle to maintain momentum when they have to leave their editor, switch windows, and copy and paste code to find the right prompts. This constant back-and-forth can be a major source of frustration.
Limited Integration with Real Tools: ChatGPT is a chatbot, not a dev tool. It can’t open files, run your test suite, or suggest direct, in-line changes in your editor.
Security & Privacy Concerns: For many developers, especially those in enterprise teams, pasting proprietary or sensitive code into a public website is a non-starter. Some companies even ban the use of such tools entirely due to security and privacy policies.

ChatGPT is Best Suited For

Beginners or students learning new concepts.
Developers who want a general-purpose AI helper.
Quick, out-of-context coding or non-coding tasks (docs, brainstorming, etc.).

Continue: An Integrated Coding Assistant

Continue is an AI coding agent that lives right in your IDE (like VS Code or JetBrains) and CLI. It is built to enhance development workflows, be deeply customizable, and continuously learn from development data. With Continue, you can connect to and use any LLM (e.g. OpenAI, Claude, or LLama for Chat) to provide code context and enable auto-completion. Continue shines at:

Understanding Your Project: Unlike ChatGPT, Continue sees the snippet you're working on and reads the entire project, including all your files, dependencies, and code structure. This means when you ask it for help, it gives you context-aware suggestions.
Helping you maintain your flow: You don't have to leave your editor. You can use its chat interface to ask a question, and it will give you in-line suggestions, even in the command line.
Giving you Control: Continue is open-source, which means you get to pick the AI model (GPT-4, Claude, or even local models) and build custom agents that match your team’s coding style.

Where It Falls Short

Setup Required: Getting it set up requires some configuration before it feels truly seamless in your workflow. However, it has a vibrant community support readily available via GitHub discussions and Discord.
Learning Curve: To unlock its full power, you'll need to spend a little time learning and configuring it to your specific needs.

Continue is Best Suited For

Developers who want coding assistance from the comfort of their IDE or use the CLI for quick command-line support.
Teams that want to avoid being trapped in a single proprietary platform.
Teams that want to standardize their processes, share custom rules, best practices, and project-specific knowledge for consistency and efficiency.
Developers who want to take control and customize their own coding environment and workflow.

Key Features of Continue

Continue comes with key features that cover almost everything you’d expect from a coding assistance: Chat, autocomplete, edit, apply, embed, and rerank.

Chat: The most basic but most versatile feature. I used it on a messy debugging session, it didn’t give a generic answer, but also pointed at the actual errors within the context of my project.
Autocomplete: It uses project context to suggest the next snippet of code you’re about to write. You just hit Tab, and the boilerplate code writes itself. This feels especially helpful when writing repetitive tests or setting up configs across multiple files.
Edit: You can select a chunk of code, type “refactor this,” and it will refine it into something clean and readable in seconds.
Apply: You can trigger an action to generate unit tests for a given file or auto-document a function. Instead of chatting back and forth, actions are executed directly.
Embed: It converts your code into a unique numerical representation, allowing the AI to perform a semantic search.
Rerank: It improves search relevance by reordering initial results based on their true semantic meaning, ensuring the most useful information is always at the top.

So, Which One is Right for You?

At the end of the day, these tools aren’t competitors, but they complement each other. The choice between a generalist like ChatGPT and Continue comes down to your priorities.

If you're looking for a versatile tool for learning and getting high-level answers, ChatGPT is a fantastic resource. On the other hand, if your goal is to build, refactor, or debug code in a secure workflow all from within your editor or command line, then Continue is your best bet.

Beginners Guide Contributing To Apache APISIX

Anita Ihuman 🌼 — Mon, 25 Apr 2022 08:18:46 +0000

Have you been looking for ways to get involved and actively contribute to Apache Software Foundation’s newest top-level project(Apache APISIX)? Then, this article is for you.

Several articles and videos already exist that explain the open-source tool Apache APISIX and what its all about. This article gives you a walkthrough on contributing and collaborating in the APISIX community.

Meet with the community

There are several ways you can get in touch with the Apache APISIX community. To kickstart your contribution journey, jump into our community by:

Subscribe to mailing

The mailing list is a great place to start, as most of the discussions regarding the project are deliberated via the mailing list. Subscribing to this mailing is easy as pie. Follow the steps here.

Joining the slack

The slack channel is another way to meet and collaborate with the APISIX community. Our slack community is a safe place to learn, educate and engage with the community. You can ask questions here, as the community managers and maintainers are always on standby. Follow this link to join the slack.

Attending weekly meetings

We also have a weekly call that goes on every Wednesday. Our community weekly focuses on improving the engagement and collaboration among community members. You will receive an invite to this meeting upon subscribing to the mailing list.

How can you get involved?

You can identify with the Apache APISIX project and community in the following ways.

Through Internship programs

APISIX has been actively participating in some internship programs since 2019, like Outreachy, GSOD and APISIX Summer of Programing. These programs serve as a medium to welcome more open-source enthusiasts into the community and projects as mentees. At the end of each internship period, mentees are fully equipped with the knowledge of Apache APISIX and how to contribute.

As a contributor

For most open source enthusiasts, you can join the Apache APISX community as a first-time contributor. There are different ways you can make valuable contributions. We will look at other ways you can contribute to the project and community shortly.

As a user

As a project owner, you can also get involved in our community by testing and integrating our project. APISIX serves as an excellent API gateway, delivering dynamic, real-time, high-performance & traffic management features. Apache APISIX consists of a data plane to dynamically control request traffic, a control plane to store and synchronise gateway data configuration, an AI plane to orchestrate plugins and real-time analysis and processing of request traffic.

As an evangelist

Apache APISIX, although a top-level project, is still in its early stages. You can get involved in our community by spreading the word about this cloud-native gateway project; through articles, videos, and conferences.

How to start your contributions

Some open-source enthusiasts are interested in contributing to the Apache APISIX project but are unsure where to start. These are the different ways you can become an active contributor to the cloud-native project.

Help with translations

In the hope of an inclusive project, the APISIX developers are working on translating the code and documents to a universal language. If this is an area you find interesting, get started by picking up an issue regards translating parts of the codebase to English. If you come across our documentation and code that requires translation, feel free to create an issue accordingly or discuss it on the mailing list.

Help with documentation

Our team of technical writers are currently restructuring the Apache APISIX documentation. That is to say, there are several ways you can put your writing skills to good use in APISIX. While reading through our documentation, if you encounter any issues that need to be addressed, you can create an issue accordingly or discuss it on the mailing list. You can also contribute by creating written articles that promote APISIX. They will be featured on the APISIX blog.

Help with outreach and engagement.

While technical skills are most welcome, the Apache APISIX community also support contributors with soft skills. This includes advocacy, marketing, and moderating our community channels. An excellent place to start is to familiarise yourself with our community, where you can ask questions and provide answers for others. You can also promote the Apache APISIX community, projects and content on your media platform.

Help report or fix a bug.

Apache APISIX projects are built on Lua, Go, and JavaScript as the core language. Creating issues based on bugs you noticed within our code base is an excellent way to contribute to the APISIX project. Several issues are yet to be assigned within the Apache APISIX repository. You can also check out the other repositories under Apache APISIX. Remember to carefully read through the contributing guide to contribute to the code base successfully.

Help out with the design.

Contributors with design insight(UI/UX), your skills are welcomed too. APISIX has a dashboard designed to make it easy for users to operate Apache APISIX through a frontend interface. You can flex your design skills by improving on the existing designs. Designs contributions are discussed among community members via mailing list before implementation.

Help test and assure quality.

As a developer, you can check the Apache APISIX project for bugs and makes lists of defects for our engineers to attend to. Your reviews will help us ensure quality throughout the delivery cycle of Apache APISIX.

Star Apache APISIX repositories

Last but not least, remember to show appreciation to our developers and contributors by staring our project.

Conclusion

As a first time contributor, breaking into the community might be overwhelming at first, so feel free to ask questions as much as you have. If you have any concerns that require immediate attention, use the mailing list to communicate with the team. Always adhere to our code of conduct. Then, remember to tag a friend along.

Apache APISIX Ingress Controller Over the K8s Native Ingress

Anita Ihuman 🌼 — Tue, 12 Apr 2022 14:10:37 +0000

What is Ingress?

An ingress is an API object that allows access to your Kubernetes services from outside the Kubernetes cluster by defining the edge-entry traffic routing rules (e.g. load balancing, SSL termination, path-based routing, protocol). The ingress manages external access to the services within a cluster using public IP and port mapping.

The component responsible for carrying out this action is called the Ingress controller.

Role of K8s Ingress Controller in a Cluster?

In a Kubernetes application, pods run inside a cluster while a load balancer runs outside. The load balancer is responsible for accepting connections from the internet and routing them to an edge proxy located within your cluster. This edge proxy is in charge of routing traffic into your pods. You can route multiple back-end services through a single IP address using ingress.

An ingress controller is a third party edge-proxy that implements ingress. They are responsible for reading the Ingress Resource information and processing that data accordingly. The ingress controller does not replace the load balancer; instead, it adds a layer of routing and control behind the load balancer.

It aids in the consolidation of routing rules into a single location.
It is declared, created, and destroyed independently from the services you wish to expose.
It is configured using the Kubernetes API to deploy objects called “Ingress Resources.”

The Drawbacks

Kubernetes provides several methods for exposing edge interfaces, including node port, load balancer, ingress, etc. Ingress is unquestionably a more cost-effective way to use reverse proxies as it reveals a limited number of public IPs. However, it is accompanied by specific risks like complexity, latency, and security once implemented. These issues are frequently intertwined; the others will likely be if one is present.

Complexity:

Microservice architectures are built with lightweight and simple designs, and this is a feature most organizations look out for in their application. However, the K8s ingress does not stick to these principles, as it is developed mainly using complex scripts and functions. This results in complexities for the underlying engine it is implemented on and even more confuses the configurator. Kubernetes being an overcomplicated tool, having to implement other complex features might affect your application’s scalability and overall performance.

Lack of support for stateful load balancing:

Kubernetes is an operation and maintenance-oriented non-business management system. As a result, complex load balancing solutions such as session persistence are not supported. It also does not support these contradicting load balancing solutions in the short run.

Google has already attempted to address this issue with its service mesh solution (istio). The istio architecture is flawless. However, it compromises performance, which can be remedied using its mixer v2.

Dynamic adjustment of weights:

It is tricky to control traffic by percentage in Kubernetes, although this is one feature most organizations look out for. However, after v1.8, Kubernetes began supporting IPVS as a Kube-proxy startup parameter or Kube-route’s annotation.

Weak scalability:

Although developers created ingress to tackle edge traffic, people’s desire for managing edge traffic is equal to or greater than their need for internal traffic.

Business-level grayscale control, fusing, flow control, authentication, and flow control are the basic requirements popular on ingress. However, native ingress extension is limited in these aspects.

Reload problem:

The YAML configuration file is analyzed by the ingress controller, transformed to Nginx.conf, and then triggered to reload Nginx.conf to make the setting take effect in the architecture of Kubernetes native ingress.

Routine operation and maintenance inevitably touch the ingress YAML configuration occasionally. Every time the configuration takes effect, it will trigger a reload. It is unacceptable, primarily when edge traffic uses long connections, which are more likely to cause accidents.

Why Apache APISIX Ingress Controller?

APISIX Ingress is another Ingress Controller implementation. APISIX Ingress differs from Kubernetes Ingress Nginx in that it uses Apache APISIX as the actual data plane for business traffic. Using Apache APISIX as an ingress implementation can help address the above drawbacks while also providing the community with an additional ingress controller option.

Tackles the complexities:

In Apache APISIX, we can write logic through plug-in code to expose a simple configuration interface, which is convenient for configuration maintenance and avoiding the interference of scripts to configuration personnel.

Support for stateful load balancing:

Apache APISIX natively supports load balancing such as session persistence and reserves the expansion capability of the balancer stage. Since Kubernetes permits project expansion, it is possible to enlarge the advanced load balancing requirements based totally on Apache APISIX.

Dynamic in nature:

Apache APISIX abstracts main objects like route, service, consumer, upstream, plug-in, and so on, and operations like weight adjustment are naturally supported. Hence, changing the node weight under upstream.

Ability to expand:

In terms of expansion capabilities, Apache APISIX supports plug-ins. In addition to the officially offered plug-ins, you can create custom plug-ins to satisfy your specific needs.

Hot reload:

Apache APISIX supports hot configuration, and routes can be defined and modified at any time without triggering Nginx reload. So whether you add, delete or alter plug-ins and update codes of plug-ins within the disk, you don’t need to restart the service.

Implementing APISIX Ingress Controller in AISpeech

AI Speech is a leading speech technology platform. It specializes in computer speech recognition, tone analysis, and dialogue management techniques.

To implement the Apache APISIX ingress controller, AISpeech considered two challenges that required immediate attention.

To synchronize the state of the Kubernetes cluster and Apache APISIX.

The Apache APISIX ingress controller project addresses this by syncing Kubernetes pod information with the upstream in APISIX. Simultaneously, the primary and backup systems are constructed to manage their high-availability issues.

To define the objects in Apache APISIX in Kubernetes Custom Resource Definitions(CRD).

The Apache APISIX ingress provides CRD support to understand declarative configurations better. State checking, however, ensures quick access to the synchronized state of declarative configurations. Because Kubernetes declares the cluster state using YAML, the CRD must be defined in Apache APISIX for the objects (route/service/upstream/plug-in) to integrate into Kubernetes.

Conclusion

There are several popular Ingress Controllers for Kubernetes, but choosing the right one for your application is always tricky. As your application scales, you need to consider an ingress controller that aligns with your Kubernetes application in testing and production mode. The Apache APISIX ingress controller is an open-source project that answers all these needs.

HelloTalk: Leveraging Apache APISIX and OpenResty

Anita Ihuman 🌼 — Tue, 05 Apr 2022 09:48:03 +0000

When it comes to offering reliable and high-performance services worldwide, most communication systems encounter several cross-border problems. This article uncovers how HelloTalk overcomes these challenges, emerging as the world’s largest social foreign language learning platform using OpenResty and Apache APISIX.

What is HelloTalk?

HelloTalk is a language learning social platform that serves as a platform for diverse speakers of different cultures to teach and learn languages globally. There are over 160 languages that you can learn on HelloTalk. Some languages are: Arabic, Cantonese, English, French, Vietnamese, German, Italian, Japanese, Korean, Mandarin Chinese, Portuguese, Spanish, and more.

Conversing, mistake correction and translation are all included in the program, and users may alter text by voice while chatting. HelloTalk supports voice to text and translation for over 100 languages. HelloTalk prioritizes both local and international communities of users by delivering high-quality services.

Users can learn other native languages and cultures with the community’s help. It is also a fantastic way to meet new people! HelloTalk has over 16 million users who are free to connect with learning partners for the language they wish to learn. Instead of conventional classes, users learn from a community of learners. Furthermore, users can also practice what they’ve learned on smartphones or tablets.

Challenges of Internationalization

The HelloTalk users are widely spread. Therefore, It is necessary to find a solution to the problem of dispersed user distribution zones.
Around 20% of HelloTalk customers in China are encountering firewall issues.
The language environment in other nations is as complex as the network environment, making language adaptation a problematic task.

As illustrated in the diagram above, HelloTalk users are distributed worldwide. The distribution of HelloTalk users in Asia-Pacific, like South Korea, Japan, the Yangtze River Delta, and China’s Pearl River Delta, is significantly concentrated, making it easy to manage. However, delivering reliable service is difficult in other areas where customers are extensively dispersed, such as Europe, Africa, and the Middle East.

How To Improve User’s Global Access Quality

When thinking of improving the global user experience, HelloTalk considers two issues: cost and authentic quality of service. International customers are directly accelerated back to Alibaba in Hong Kong. Although direct acceleration risks degrading the client’s network quality due to geographical issues, HelloTalk implemented failover measures to improve user experience.

Access Line Control and Traffic Management: The stability brought by the dedicated line network, such as Europe to Hong Kong, delay: 244 ms -> 150 ms;
Dynamic upstream control (Lua-resty-healthcheck); flexible switching between several service provider lines is considered to ensure service reliability.
Part of the logic can be processed directly at the edge, serverless (the principle is reliant on pcall + loadstring implementation), by transforming serverless into Apache APISIX + ETCD.
Access Node and Quality Control

Due to how dispersed the access nodes of HelloTalk are, the United States can’t go directly to Hong Kong. Instead, the established mechanism only transfers to Germany before Hong Kong. So, to ensure that the user experience is not affected, Hellotalk considers specific failover measures to ensure that users can move between multiple service providers.

Choice of 7-layer and 4-layer Acceleration: Many service providers will provide 7-layer acceleration and 4-layer acceleration, but some problems need to be solved.

Layer 4 acceleration: The SSL handshake time is too long and easy to fail, so it cannot obtain the client’s IP. Hence, making it inconvenient to the node quality statistics.
Layer 7 acceleration: IM(Instance Message) services cannot guarantee the reliable arrival of messages that require a long connection

A management solution for global access in a multi-cloud environment:

Layer 7 acceleration with support for WebSockets. (cloud service + self-built).
Self-built low-speed VPC + dedicated line channel. (Considering the cost-effectiveness, IM itself does not have much traffic, so it only sends notification messages)
Mixed sending and receiving messages with long and short connections: WebSocket + long polling + httpdns + built-in IP failover mechanism.

Why OpenResty?

OpenResty is a programming language that can create scalable online applications, web services, and dynamic web gateways. The OpenResty architecture is built on standard Nginx core and a variety of 3rd-party Nginx modules that have been enhanced to turn Nginx into a web app server capable of handling a vast number of requests.

HelloTalk’s IM services were once written in C++, and at that time, it used a high-performance network framework of a large manufacturing unit. Protocols were all drawn up internally, resulting in the seldom use of HTTP protocol; this didn’t seem cost-efficient for a smaller company.

Suppose the internal writing service is to be made available to the public. In that case, one must create a Proxy Server separately and the newly added command word adapted, which is time-consuming.

Hence, OpenResty was adopted to act as a proxy and directly convert the protocol to internal services. In the end, it reduced costs. The services were made available to the public, necessitating the use of WAF.

Previously, HelloTalk APIs were built using PHP; this left several loopholes due to framework issues resulting in countless cyber-attacks from hackers. The most common way was to post various PHP keywords or include PHP keys within URL characters.

HelloTalk tackled this challenge by adding tiny bits of code (based on regularisation) in OpenResty; it turned out that adding the WAF(Web application firewall) function did not affect performance loss.

Integrating OpenResty helped to tackle some of these challenges with the following benefits:

Quickly implement a Web IM: Most mainstream IM(Instance Message) apps like WhatsApp and WeChat offer Web IM; hence the WebIM version of HelloTalk was implemented from the server-side based on OpenResty’s compatibility and modification of protocols. This was possible by simply adding a layer of OpenResty in the middle for WebSocket protocol conversion.

By putting PHP function names in the WAF, all attempts of cyber attacks are blocked and unable to reach PHP.
With openRestry, message limiting became possible, controlling the frequency of API calls/messages, which occurs directly based on resty.limit.req.

Integrating Apache APISIX

What is Apache APISIX

Apache APISIX is a dynamic, real-time, high-performance API gateway. It offers traffic management features such as load balancing, dynamic upstream, canary release, service meltdown, authentication, observability, and other rich traffic management features. It’s built atop the Nginx reverse proxy server and the key-value store etcd, to provide a lightweight gateway.

In the early days, to achieve dynamic modification for HelloTalk, Nginx.conf was altered directly to render the best performance, just as an API gateway would.

This proved a possible solution to achieving the high performance, dynamic update of SSL certificate, Location and upstream. Similar to the K8S ingress update mechanism, generated through a template: nginx_template.conf + JSON -> PHP -> Nginx.conf -> PHP -CLI -> Reload. The challenge with using this method was that many individuals forgot the priority order rules established by Location, often resulting in mistakes.

The adoption of Apache APISIX as the API gateway for HelloTalk reduced these challenges significantly with these benefits:

APISIX is established on the Nginx library and etcd, saving the maintenance cost.
The code is straightforward to comprehend, and it may understand regardless of skill set.
It offers rich traffic management features such as load balancing, dynamic upstream, canary release, circuit breaking, authentication, observability, etc.
It is an actively maintained project, and contributors/maintainers are prompt to render support via mailing lists.
APISIX is relatively simple and easy to configure; although it is cumbersome, it does not rely on RDMS(Relational Database Management System), incurring additional maintenance costs.
Apache APISIX is based on lua-protobuf. Hence, HelloTalk switched to using the lua-protobuf library, which can directly convert a PB object into JSON, making it convenient.

Conclusion

This post explains how HelloTalk previously devised alternative ways of achieving reliable and high-performance services globally. I also discussed the challenges with these configurations and the success story of adopting Apache APISIX and OpenResty.

Consider going through the docs for an in-depth understanding of Apache APISIX and its features.

You can find the original recording from HelloTalk on this topic here.
Originally published on Medium on April 5th, 2022.