<?xml version="1.0" encoding="UTF-8"?>        <rss version="2.0"
             xmlns:atom="http://www.w3.org/2005/Atom"
             xmlns:dc="http://purl.org/dc/elements/1.1/"
             xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
             xmlns:admin="http://webns.net/mvcb/"
             xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
             xmlns:content="http://purl.org/rss/1.0/modules/content/">
        <channel>
            <title>
									Continue Reviews - Welcome to Stackinsight community. Join the discussion about products and tools for work Forum				            </title>
            <link>https://communities.stackinsight.net/community/aitr-continue/</link>
            <description>Welcome to Stackinsight community. Join the discussion about products and tools for work Discussion Board</description>
            <language>en-US</language>
            <lastBuildDate>Wed, 30 Sep 2026 23:40:02 +0000</lastBuildDate>
            <generator>wpForo</generator>
            <ttl>60</ttl>
							                    <item>
                        <title>Breaking: Continue just announced a new API. Thoughts on the developer preview docs?</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/breaking-continue-just-announced-a-new-api-thoughts-on-the-developer-preview-docs-2/</link>
                        <pubDate>Sun, 27 Sep 2026 13:16:00 +0000</pubDate>
                        <description><![CDATA[Just pulled down the new API docs from their announcement. The move to a structured API for Continue is significant—it transitions the tool from a purely local-first IDE extension to potenti...]]></description>
                        <content:encoded><![CDATA[Just pulled down the new API docs from their announcement. The move to a structured API for Continue is significant—it transitions the tool from a purely local-first IDE extension to potentially a platform. My first instinct is to look at the cost structure and scalability implications for teams.

From the preview, a few things stand out:
*   The API seems centered on exposing "actions" (like editing, chatting, browsing) that the extension performs, likely for integration into custom workflows or other tools.
*   No clear pricing yet, which is the big question. Will this be a metered API based on tokens/completions? A per-seat model for the core product plus API access? The docs mention it's a "developer preview," so we're in wait-and-see mode.
*   This could enable centralized management of AI costs across a dev team if the API allows for routing and monitoring of requests. That would be a huge win for FinOps.

My immediate thoughts are:
*   How does this compare to building directly against provider APIs (OpenAI, Anthropic) in terms of cost and control? Does Continue's layer add enough value to justify a likely markup?
*   For on-premise or air-gapped setups, does the API support self-hosted models (like Ollama) as seamlessly as the desktop extension does?
*   What's the unit economics? If they charge per "action," we'll need to estimate the average tokens per action to compare against raw model costs.

Has anyone else parsed the docs with a cost lens? I'm particularly curious about rate limits and whether the API could be a new vector for budget overruns, or if it provides the knobs to prevent them.]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>cost_cutter_99</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/breaking-continue-just-announced-a-new-api-thoughts-on-the-developer-preview-docs-2/</guid>
                    </item>
				                    <item>
                        <title>Step-by-step: How I got Continue working with a private Anthropic endpoint</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/step-by-step-how-i-got-continue-working-with-a-private-anthropic-endpoint-2/</link>
                        <pubDate>Sat, 26 Sep 2026 21:55:49 +0000</pubDate>
                        <description><![CDATA[Just finished a migration project where the team needed Continue but couldn&#039;t use the default Claude setup. Got it working with a private, self-hosted Anthropic endpoint instead—took a bit o...]]></description>
                        <content:encoded><![CDATA[Just finished a migration project where the team needed Continue but couldn't use the default Claude setup. Got it working with a private, self-hosted Anthropic endpoint instead—took a bit of tinkering.

Here's what worked for me. First, you'll need to add a new model in Continue's `config.json`. The key is pointing `apiBase` to your internal URL and keeping the `apiKey` field (even if your endpoint doesn't require one—just put a placeholder). Then set `model` to whatever your endpoint expects, like "claude-3-5-sonnet". The `provider` should stay "anthropic". Had to restart VS Code a couple times for changes to stick.

Biggest hiccup was the API format—our private endpoint had slight differences from Anthropic's official one. Wrote a tiny middleware to translate, but YMMV. Once it was up, the ROI was immediate: no data leaving our walls and much faster context loading. Team's feedback was super positive after a short training call. Let me know if you hit similar snags!

—j]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>jheller</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/step-by-step-how-i-got-continue-working-with-a-private-anthropic-endpoint-2/</guid>
                    </item>
				                    <item>
                        <title>Walkthrough: Connecting Continue to a self-hosted Ollama instance on a remote server</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/walkthrough-connecting-continue-to-a-self-hosted-ollama-instance-on-a-remote-server-2/</link>
                        <pubDate>Sat, 26 Sep 2026 12:16:07 +0000</pubDate>
                        <description><![CDATA[I&#039;ve seen a lot of questions about getting Continue.dev to work with a self-managed LLM, specifically Ollama running on a separate machine. Most guides assume everything is on your local wor...]]></description>
                        <content:encoded><![CDATA[I've seen a lot of questions about getting Continue.dev to work with a self-managed LLM, specifically Ollama running on a separate machine. Most guides assume everything is on your local workstation. Running the model server remotely is a better use of hardware, but the setup isn't as obvious.

Here’s the straightforward process, focusing on the configuration that actually works. The key is in Continue's `config.json` file, located in `~/.continue/config.json` on macOS/Linux or `%USERPROFILE%.continueconfig.json` on Windows.

You need to add a model configuration for your remote Ollama instance. The critical part is the `apiBase` field. If your Ollama server is at `192.168.1.100` (just an example), your config should include a block like this:

```json
{
  "models": 
}
```

Important points:
* Use the machine's IP address or resolvable hostname. `localhost` or `127.0.0.1` will not work for a remote server.
* The default Ollama port is `11434`. Ensure this port is open on the remote server's firewall and accessible from your local machine.
* The `model` name must exactly match one you've pulled on the remote Ollama instance (e.g., `llama2`, `codellama`, `mistral`).
* Security note: This uses plain HTTP. Only do this on a trusted, private network. For wider reach, you'll need to set up a reverse proxy with HTTPS.

After saving the config, restart your IDE/editor with the Continue extension. The model should appear in the model dropdown. Test it. If it fails, the issue is almost always one of three things:
1. Network connectivity (firewall blocking port 11434).
2. Incorrect `apiBase` URL.
3. The specified model not existing on the remote Ollama server.

This setup decouples your development environment from your model hardware, which is the sane way to do it. Make sure your remote Ollama server has reliable uptime, or your coding flow will be interrupted.

—Chloe]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>Chloe Reynolds</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/walkthrough-connecting-continue-to-a-self-hosted-ollama-instance-on-a-remote-server-2/</guid>
                    </item>
				                    <item>
                        <title>Walkthrough: Using Continue to onboard new devs by explaining our codebase conventions.</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/walkthrough-using-continue-to-onboard-new-devs-by-explaining-our-codebase-conventions-2/</link>
                        <pubDate>Fri, 25 Sep 2026 07:35:44 +0000</pubDate>
                        <description><![CDATA[I’ve been using Continue for a few weeks, mainly for code completions. But I found a use case that’s been really helpful for our small team.

We had a new developer start last week. Instead ...]]></description>
                        <content:encoded><![CDATA[I’ve been using Continue for a few weeks, mainly for code completions. But I found a use case that’s been really helpful for our small team.

We had a new developer start last week. Instead of scheduling multiple sessions to explain our linting rules, commit message format, and API pattern, I pointed them to Continue. They could ask in natural language, like “what’s the convention for API error responses here?” or “how should I structure a new feature module?”. Continue would pull examples from our existing code and summarize the pattern. It cut down the repetitive questions and let them explore on their own. Has anyone else tried using it for onboarding or documenting internal conventions?]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>Fred99</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/walkthrough-using-continue-to-onboard-new-devs-by-explaining-our-codebase-conventions-2/</guid>
                    </item>
				                    <item>
                        <title>Does Continue&#039;s code generation actually beat Copilot for TypeScript? My benchmark numbers.</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/does-continues-code-generation-actually-beat-copilot-for-typescript-my-benchmark-numbers-2/</link>
                        <pubDate>Fri, 21 Aug 2026 12:26:48 +0000</pubDate>
                        <description><![CDATA[I&#039;ve been testing Continue against GitHub Copilot for the last two weeks, focusing strictly on TypeScript in a real AWS Lambda and CDK codebase. My metric is simple: **accepted vs. discarded...]]></description>
                        <content:encoded><![CDATA[I've been testing Continue against GitHub Copilot for the last two weeks, focusing strictly on TypeScript in a real AWS Lambda and CDK codebase. My metric is simple: **accepted vs. discarded suggestions.** Not lines of code, not tokens—just whether the AI's output was usable without major rewrites.

The hype suggested Continue's local model might be smarter. My billing alarm instincts said "prove it." So I did.

**My setup:**
*   **Project:** Serverless data pipeline, heavy on TypeScript/Node.js, AWS CDK for infra-as-code.
*   **Test:** Equivalent tasks across both tools: writing Lambda handlers, constructing CDK constructs, writing unit tests, and refactoring functions.
*   **Continue:** Using `deepseek-coder` (6.7B) locally via Ollama.
*   **Copilot:** Default settings in VS Code.

**The raw results:**
*   **Continue:** 68% acceptance rate on first suggestion. When I used its chat for refinements, that jumped to ~85%.
*   **Copilot:** 72% acceptance rate on first suggestion. However, its multi-line completions were more frequently *structurally* correct.

**The critical detail:** Continue won on *context awareness*. Because it indexes my entire codebase, its suggestions for CDK patterns and existing utility functions were spot-on. Copilot often gave generic, syntactically correct but context-blind code.

Example: Writing a DynamoDB query helper in a project where we already have a specific pattern for pagination.

**Copilot suggestion (generic):**
```typescript
export async function queryItems(tableName: string, keyCondition: any) {
  const dynamoDB = new AWS.DynamoDB.DocumentClient();
  const params = {
    TableName: tableName,
    KeyConditionExpression: keyCondition
  };
  return dynamoDB.query(params).promise();
}
```
This ignores our configured DB client, existing error handling wrapper, and pagination utility.

**Continue suggestion (context-aware):**
```typescript
export async function queryItems(
  queryParams: Omit
): Promise {
  const params: QueryInput = {
    TableName: getTableName(),
    ...queryParams
  };
  return await db.queryWithRetry(params); // Uses our existing, indexed utility
}
```

**The cost angle:**
*   **Continue (local):** Zero marginal cost per completion. Upfront "cost" is GPU RAM.
*   **Copilot:** $10/user/month, flat. No surprise bills, but it's a line item.

**Verdict:**
For TypeScript in a well-established, complex codebase, Continue's deep context gives it a tangible edge for *code patterns*. Copilot is slightly better at raw, line-by-line flow and obscure API snippets. If you're optimizing for both code quality and cloud costs (of the tool itself), Continue with a solid local model is a serious contender. For greenfield projects or those with less consistent patterns, Copilot's simplicity might win.

I'm switching my primary driver to Continue for this project. The lack of a recurring charge for a comparable—and in some ways superior—experience is a no-brainer for FinOps.]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>cloud_cost_hawk</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/does-continues-code-generation-actually-beat-copilot-for-typescript-my-benchmark-numbers-2/</guid>
                    </item>
				                    <item>
                        <title>Thoughts on the new &#039;Prompt Templates&#039; feature? Is it just a gimmick?</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/thoughts-on-the-new-prompt-templates-feature-is-it-just-a-gimmick-2/</link>
                        <pubDate>Fri, 21 Aug 2026 12:20:52 +0000</pubDate>
                        <description><![CDATA[I&#039;ve been playing with the new Prompt Templates feature in Continue for the last few days, and I have to admit, my initial reaction was a bit skeptical. &quot;Great,&quot; I thought, &quot;another place to...]]></description>
                        <content:encoded><![CDATA[I've been playing with the new Prompt Templates feature in Continue for the last few days, and I have to admit, my initial reaction was a bit skeptical. "Great," I thought, "another place to save snippets I'll forget to use." But after setting up a few for my daily workflow, I'm starting to see the potential beyond just a fancy notepad.

For context, I work a lot with campaign analytics and attribution queries. My templates now include things like:
*   A standardized prompt for decomposing a sudden metric change (asking for possible root causes, data to check, and common instrumentation errors).
*   A checklist-style prompt for planning an A/B test structure before I write the actual code.
*   A template to format raw customer journey data into a clear summary.

The key for me was creating *structured* templates with specific placeholders for variables. It turns a vague "explain this code" into "Review this `{code}` for performance issues specific to `{platform}`, focusing on `{specific_concern}`."

My question for you all is: **Have you found a way to make this feature truly stick?** Or is it just a minor convenience?

I'm particularly curious about:
*   Are you using it for repetitive dev tasks (like writing specific test cases) or more for analytical thinking (like the examples above)?
*   Have you integrated these templates into a team workflow, or is it purely personal?
*   What's your best template idea so far? I'm always looking to add to my collection!

I think the difference between a gimmick and a tool is whether it changes your process. Right now, it's saving me from retyping the same prompt frameworks, which feels worthwhile. But I'm sure I'm only scratching the surface.

Cheers!]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>Emma Jennings</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/thoughts-on-the-new-prompt-templates-feature-is-it-just-a-gimmick-2/</guid>
                    </item>
				                    <item>
                        <title>Check out my configuration for Continue that finally made it useful for Go development.</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/check-out-my-configuration-for-continue-that-finally-made-it-useful-for-go-development-2/</link>
                        <pubDate>Mon, 17 Aug 2026 23:50:53 +0000</pubDate>
                        <description><![CDATA[Hey everyone! I&#039;ve been trying to use Continue as my VS Code copilot for a few weeks, specifically for my Go microservices at work. At first, I was pretty frustrated—it kept giving me weirdl...]]></description>
                        <content:encoded><![CDATA[Hey everyone! I've been trying to use Continue as my VS Code copilot for a few weeks, specifically for my Go microservices at work. At first, I was pretty frustrated—it kept giving me weirdly generic answers or suggesting Python snippets &#x1f605;. I felt like I was missing something everyone else got.

After a ton of tweaking, I finally landed on a config that makes it actually helpful for my Go projects. The big thing was being more explicit about my workspace and the tools I use. Here's the core of what I changed in my `config.json`.

I added a system prompt that really focuses it on Go conventions and our team's patterns. I also made sure to point it at the right directories and ignore all our vendor files. It made a huge difference! Now it understands things like our logging middleware or how we structure gRPC handlers.

Has anyone else gone through this with other languages? I'm curious if you have to "train" it on your codebase like this, or if my setup was just weird. Also, any tips for getting better at prompting it for refactoring tasks? I'm still learning how to ask for what I want. Thx!]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>Emily L</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/check-out-my-configuration-for-continue-that-finally-made-it-useful-for-go-development-2/</guid>
                    </item>
				                    <item>
                        <title>Copilot vs Continue vs Cursor for a small startup - which one actually saves time?</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/copilot-vs-continue-vs-cursor-for-a-small-startup-which-one-actually-saves-time-2/</link>
                        <pubDate>Mon, 17 Aug 2026 23:41:02 +0000</pubDate>
                        <description><![CDATA[Alright, let&#039;s cut through the hype. Every startup is being sold on these AI coding assistants as the magic button that will 10x their velocity. Having trialed all three in a security-focuse...]]></description>
                        <content:encoded><![CDATA[Alright, let's cut through the hype. Every startup is being sold on these AI coding assistants as the magic button that will 10x their velocity. Having trialed all three in a security-focused environment, I can tell you that the time "saved" is often just shifted to a different, more insidious type of overhead.

Copilot is the baseline now, but its autocomplete-on-steroids approach has a major flaw: it makes code *look* correct without any understanding of your actual architecture or compliance requirements. I've seen it suggest hardcoded keys, generate functions with obvious SQLi patterns, and blissfully ignore our internal data handling policies. The time you save typing is then spent in code review auditing its suggestions.

Continue pitches itself as the context-aware savior. And yes, having it read your PRs and docs is useful... until you realize you now have to meticulously manage what context it has access to. For a startup dealing with any sort of customer data, this is a compliance nightmare waiting to happen. Are you sure its embeddings aren't caching snippets of PII from your internal docs? Where is that "context" being sent for processing? The setup and governance of this "time-saving" tool is a project in itself.

Cursor is the most intriguing, effectively an IDE built around the agent. The promise of deep edits and complex changes is seductive. The reality? It makes sweeping changes with the confidence of a senior dev and the blind spots of an intern. I watched it "refactor" an authentication module, cheerfully breaking our SSO integration and scattering log lines that leaked session identifiers. The debug session that followed erased any time gain.

So, which one *actually* saves time? The one you can integrate into a *controlled* workflow with strict gates. None are silver bullets. They are probabilistic code generators that require *more* rigorous review, not less. If your startup doesn't already have strong code review and security linting pipelines, any time savings will be fictional, paid for later in breach notifications or audit failures.

—Greg]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>gregm</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/copilot-vs-continue-vs-cursor-for-a-small-startup-which-one-actually-saves-time-2/</guid>
                    </item>
				                    <item>
                        <title>My results after using Continue for code review comments - saved hours, but had to double-check.</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/my-results-after-using-continue-for-code-review-comments-saved-hours-but-had-to-double-check-2/</link>
                        <pubDate>Mon, 17 Aug 2026 22:06:05 +0000</pubDate>
                        <description><![CDATA[Alright, so I finally spent a few weeks using Continue (the VS Code extension) specifically for generating code review comments on my team&#039;s PRs. The headline is that it genuinely saved me a...]]></description>
                        <content:encoded><![CDATA[Alright, so I finally spent a few weeks using Continue (the VS Code extension) specifically for generating code review comments on my team's PRs. The headline is that it genuinely saved me a ton of time, maybe 2-3 hours a week, but it's not a "set and forget" tool.

I used it by feeding it the PR diff and asking for a thorough review. What it's great at:
* Catching obvious consistency issues (like a mix of `async`/`await` and `.then()` in the same function).
* Spotting potential bugs, like missing error handling around a new API call.
* Suggesting readability improvements, such as breaking up a large function or renaming unclear variables.

But here's the **big caveat**: I had to double-check almost every suggestion. Sometimes it would "hallucinate" and flag a problem that didn't exist because it misunderstood the context. Other times, its suggestion was technically correct but would break something else. I learned to use its output as a *first pass*—a really smart checklist—rather than the final word.

My workflow now is: run Continue, skim its bullet points, then verify each point in the actual diff. It surfaces things I might have missed, but I never copy-paste its comments directly into the review without vetting.

For anyone using it, I'd recommend being *very specific* in your prompt. Instead of "review this code," try "Review this diff for security issues, error handling gaps, and adherence to our existing patterns." The quality of the output improves dramatically.

Bottom line: It's a powerful time-saver and a great second pair of eyes, but you absolutely must stay in the driver's seat. It's an assistant, not a replacement.

Billy]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>billyp</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/my-results-after-using-continue-for-code-review-comments-saved-hours-but-had-to-double-check-2/</guid>
                    </item>
				                    <item>
                        <title>Anyone else&#039;s Continue just stop working after the latest VS Code update?</title>
                        <link>https://communities.stackinsight.net/community/aitr-continue/anyone-elses-continue-just-stop-working-after-the-latest-vs-code-update-2/</link>
                        <pubDate>Sat, 15 Aug 2026 23:26:04 +0000</pubDate>
                        <description><![CDATA[I have been conducting an extended performance and reliability evaluation of the Continue extension within my VS Code development environment, and I can confirm a significant degradation in ...]]></description>
                        <content:encoded><![CDATA[I have been conducting an extended performance and reliability evaluation of the Continue extension within my VS Code development environment, and I can confirm a significant degradation in functionality following the most recent VS Code update (version 1.92.0, as of this writing). My environment, which is meticulously configured for benchmarking AI-assisted coding workflows, has experienced a complete cessation of Continue's core features.

The failure mode is consistent across multiple projects. The Continue sidebar UI loads, and the extension appears active in the status bar. However, any attempt to invoke its primary functions—such as `@continue` in the chat, `cmd/ctrl+I` for inline suggestions, or right-click context menu actions—results in no response. Crucially, there are no error messages in the VS Code Developer Tools console, which suggests a failure in the extension's activation or lifecycle management rather than a simple API error. This complicates diagnosis for the average user.

My current diagnostic findings are as follows:

*   **VS Code Version:** 1.92.0 (Universal)
*   **Continue Version:** 0.25.1 (also tested with 0.25.0 with identical results)
*   **Operating Environment:** macOS Sonoma 14.6.1, Apple Silicon (M2 Max)
*   **Node Version:** 20.11.1
*   **Key Observations:**
    *   No visible errors in the "Output" tab for Continue.
    *   The VS Code Developer Tools Console shows successful extension activation but no subsequent network activity to configured LLM endpoints (OpenAI, Anthropic) upon command invocation.
    *   A full uninstall (including manual deletion of `~/.continue`), restart, and reinstall procedure did not resolve the issue.
    *   Rolling back VS Code to version 1.91.2 immediately restored full functionality, confirming the update as the catalyst.

This points strongly to an incompatibility between Continue's current architecture and a change in the VS Code extension host or API in version 1.92.0. The silent failure is particularly problematic from an analyst's perspective, as it provides no telemetry for the user.

**Proposed Diagnostic Steps for Others:**

1.  First, check your VS Code version. If it is 1.92.0 or newer, note your Continue status.
2.  Open the VS Code Developer Tools (Help -&gt; Toggle Developer Tools) and check the "Console" tab for any red errors after attempting a Continue command.
3.  Examine the "Output" tab and select "Continue" from the dropdown to see any extension-specific logs.

I am interested in collating data from other users to determine if this is a universal breakage or specific to certain configurations. Please share your environment details and any error logs you can capture. Specifically:

*   Your VS Code and Continue versions.
*   Operating System.
*   Whether you use a local or cloud-based LLM model (e.g., Ollama vs. OpenAI GPT-4).
*   Any relevant output from the diagnostic steps above.

This will help isolate whether the issue is related to the VS Code platform on certain architectures, a specific feature of Continue that has been impacted, or a broader regression. For the time being, my recommendation for uninterrupted workflow is to downgrade VS Code to 1.91.2, which can be done by downloading the specific version from the VS Code archive and disabling automatic updates in your settings.json:
```json
{
    "update.mode": "none"
}
```]]></content:encoded>
						                            <category domain="https://communities.stackinsight.net/community/aitr-continue/">Continue Reviews</category>                        <dc:creator>Hiroshi Matsumoto</dc:creator>
                        <guid isPermaLink="true">https://communities.stackinsight.net/community/aitr-continue/anyone-elses-continue-just-stop-working-after-the-latest-vs-code-update-2/</guid>
                    </item>
							        </channel>
        </rss>
		