<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>supermaven &#8211; iAIFeed</title>
	<atom:link href="https://www.iaifeed.com/tag/supermaven/feed" rel="self" type="application/rss+xml" />
	<link>https://www.iaifeed.com</link>
	<description>iAIFeed</description>
	<lastBuildDate>Sun, 15 Nov 2026 12:56:52 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.5</generator>

<image>
	<url>https://www.iaifeed.com/wp-content/uploads/2026/07/cropped-iaifeed1-80x80.png</url>
	<title>supermaven &#8211; iAIFeed</title>
	<link>https://www.iaifeed.com</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>How to Use Supermaven Context on Large Codebases</title>
		<link>https://www.iaifeed.com/how-to-use-supermaven-context-on-large-codebases</link>
					<comments>https://www.iaifeed.com/how-to-use-supermaven-context-on-large-codebases#respond</comments>
		
		<dc:creator><![CDATA[iamltlb]]></dc:creator>
		<pubDate>Sun, 15 Nov 2026 12:49:32 +0000</pubDate>
				<category><![CDATA[Blog]]></category>
		<category><![CDATA[supermaven]]></category>
		<guid isPermaLink="false">https://www.iaifeed.com/how-to-use-supermaven-context-on-large-codebases</guid>

					<description><![CDATA[Get better Supermaven completions on large repos. Index hygiene, verification tests and practice patterns that work on big codebases.]]></description>
										<content:encoded><![CDATA[<p><a href="https://www.iaifeed.com/ai-tool/supermaven">Supermaven</a>&#8216;s 300,000-token context rewards codebases with clear structure: keep files under about 400 lines, name things explicitly, and give the indexer a repository it can finish in under ten minutes. Get those three right and cross-file completions go from occasionally useful to genuinely predictive.</p>
<h2 id="how-does-the-context-window-actually-get-used">How does the context window actually get used?</h2>
<p>The extension indexes your workspace and retrieves the most relevant chunks when you type. It is retrieval, not a raw dump of every file.</p>
<p>That has a direct implication: a codebase where the relevant code is spread across 40 tiny files in 40 directories retrieves badly, because no single chunk tells the model enough. A codebase where a domain lives in three substantial files retrieves well.</p>
<p>Large context raises the ceiling. Structure determines whether you get near it.</p>
<h2 id="what-repository-hygiene-improves-completions">What repository hygiene improves completions?</h2>
<p>Five changes, all cheap:</p>
<ol>
<li><strong>Respect the ignore file.</strong> Add build output, generated clients, node_modules and vendored dependencies to the ignore list the extension uses. Indexing minified JavaScript wastes context on noise you never edit.</li>
<li><strong>Collapse generated code.</strong> If a 3,000-line schema file exists only for type generation, exclude it and let the types come from a smaller hand-authored file.</li>
<li><strong>Co-locate tests with source.</strong> A <code>user.ts</code> and <code>user.test.ts</code> next to each other gives the model examples of the API in use.</li>
<li><strong>Keep files under 400 lines.</strong> Past that, retrieval chunks lose the file&#8217;s shape.</li>
<li><strong>Name functions by intent.</strong> <code>calculateProratedRefund</code> gives the model more to work with than <code>calc2</code>.</li>
</ol>
<h2 id="how-do-you-check-that-indexing-worked">How do you check that indexing worked?</h2>
<p>There is no index inspector, so test behaviorally.</p>
<p>Open a file, type a function name you know exists elsewhere in the repo, and see if the completion completes the signature correctly. Then rename that function in its source file and try again in a different file. If the completion uses the new name, cross-file retrieval is working. If it uses the old name, it is working from stale index data — reload the window.</p>
<p>A second check: open a file in a domain you have never touched. Type a three-line function signature the way you would expect the codebase&#8217;s conventions to define it. Good completions here mean the model learned conventions, not just adjacent lines.</p>
<h2 id="what-practice-patterns-get-the-most-out-of-it">What practice patterns get the most out of it?</h2>
<p><strong>Write the signature first.</strong> Type the function name, parameters and return type, then let completion fill the body. The model does better with a specified contract than with a blank line.</p>
<p><strong>Write the comment above, not beside.</strong> A one-line doc comment describing intent, then a blank line, produces a stronger suggestion than the comment inline.</p>
<p><strong>Use it during refactors, not greenfield.</strong> In a codebase with 50 existing examples of a pattern, completion is strong. In a brand-new project with no examples, it has nothing to imitate.</p>
<p><strong>Accept partial.</strong> Full-block acceptance on unfamiliar code is how subtle bugs land. Take the first two words, finish the line yourself.</p>
<h2 id="where-it-underperforms-on-large-repos">Where it underperforms on large repos</h2>
<p>Monorepos with duplicated domain logic. If two packages both define a <code>User</code> type with different fields, retrieval may pull the wrong one and the completion will be confidently wrong. That is a structural problem, not a model problem.</p>
<p>Rapidly changing code. Indexes update, but there is a lag measured in minutes. On a branch where you just renamed twelve files, expect a stretch of stale suggestions.</p>
<p>Anything requiring reasoning across three layers of abstraction — say, an ORM call whose behavior depends on a migration. Completion predicts text; it does not trace control flow. For those cases, keep a chat-based assistant in the same editor.</p>
<h2 id="what-does-a-large-repo-setup-cost">What does a large-repo setup cost?</h2>
<p>The free tier is unlimited for individuals, so cost is mostly indexing time: first index on a 200,000-line repo took several minutes, after which it is incremental. The Pro plan near $10/month adds longer context for very large repositories and team controls; only worth it if you have hit the ceiling. Indexing is local CPU, not billed tokens.</p>
<h2 id="quick-summary">Quick Summary</h2>
<ul>
<li>Context is retrieval-based: repository structure matters as much as context size.</li>
<li>Exclude build output, generated code and vendored deps from indexing.</li>
<li>Keep source files under ~400 lines and co-locate tests with implementation.</li>
<li>Verify indexing by renaming a function and checking whether completions pick up the change.</li>
<li>Write signatures and doc comments first — they improve suggestion quality more than prompting tricks.</li>
<li>Free tier is unlimited for individuals; Pro near $10/month only for very large repos and teams.</li>
</ul>
]]></content:encoded>
					
					<wfw:commentRss>https://www.iaifeed.com/how-to-use-supermaven-context-on-large-codebases/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>How to Set Up Supermaven in VS Code</title>
		<link>https://www.iaifeed.com/how-to-set-up-supermaven-in-vs-code</link>
					<comments>https://www.iaifeed.com/how-to-set-up-supermaven-in-vs-code#respond</comments>
		
		<dc:creator><![CDATA[iamltlb]]></dc:creator>
		<pubDate>Sun, 15 Nov 2026 12:49:11 +0000</pubDate>
				<category><![CDATA[Blog]]></category>
		<category><![CDATA[supermaven]]></category>
		<guid isPermaLink="false">https://www.iaifeed.com/how-to-set-up-supermaven-in-vs-code</guid>

					<description><![CDATA[Supermaven is an AI code completion extension known for speed and a 300,000-token context. Installation, settings worth changing, and honest limits versus Copilot.]]></description>
										<content:encoded><![CDATA[<p><a href="https://www.iaifeed.com/ai-tool/supermaven">Supermaven</a> is an AI code-completion extension for VS Code, JetBrains IDEs and Neovim built around a 300,000-token context window and sub-250ms suggestion latency. The free tier is unlimited for individual use, and setup in VS Code takes about two minutes.</p>
<h2 id="what-makes-supermaven-different-from-copilot">What makes Supermaven different from Copilot?</h2>
<p>Speed and context, mainly. It reads your whole open project into a large context window rather than a small window around the cursor, which shows up in cross-file completions: rename a function in one file and the completion in another file uses the new signature.</p>
<p>It is also completions only. There is no chat panel, no agent that edits files, no test generation. If you want a conversational coding assistant, this is one piece of that stack, not a replacement.</p>
<h2 id="how-do-you-install-it">How do you install it?</h2>
<ol>
<li>Open VS Code and go to the Extensions panel.</li>
<li>Search for Supermaven and install the official extension.</li>
<li>Reload the window when prompted.</li>
<li>Sign in with GitHub or email — the extension prompts on first keystroke in an editor.</li>
<li>Open a real project, not a scratch file. Completions before indexing finishes are weaker.</li>
</ol>
<p>The whole process takes under two minutes. There is no API key to paste and no model selection — the service picks the model server-side.</p>
<h2 id="which-settings-are-worth-changing">Which settings are worth changing?</h2>
<p>Open Settings and search for Supermaven. Most defaults are sensible; four are worth a look:</p>
<table>
<thead>
<tr>
<th>Setting</th>
<th>Default</th>
<th>Change it when</th>
</tr>
</thead>
<tbody>
<tr>
<td>Suggestion delay</td>
<td>~50ms</td>
<td>Raise to 100–150ms if suggestions feel noisy</td>
</tr>
<tr>
<td>Enable for languages</td>
<td>All</td>
<td>Turn off for YAML/JSON where completions get in the way</td>
</tr>
<tr>
<td>Inline suggestions</td>
<td>On</td>
<td>Off for prose-heavy files like Markdown</td>
</tr>
<tr>
<td>Status bar indicator</td>
<td>On</td>
<td>Useful for confirming it is active</td>
</tr>
</tbody>
</table>
<p>The delay setting is the one people should adjust and rarely do. At the default, a fast typist sees a ghost suggestion appear and vanish constantly. Raising it makes the experience calmer and does not hurt acceptance rate in practice.</p>
<h2 id="how-do-you-accept-and-dismiss-suggestions">How do you accept and dismiss suggestions?</h2>
<p>Tab accepts the whole suggestion. Escape dismisses.</p>
<p>What most people miss: <strong>word-by-word acceptance</strong>. On macOS it is Ctrl+Right arrow to accept the next word; the VS Code keybinding is configurable. For a long suggested block you only half want, accepting word by word is faster than dismissing and retyping.</p>
<p>A workflow that works for unfamiliar codebases: read the suggestion before accepting it. Supermaven is fast enough that accepting blind is tempting, and that is how subtle bugs enter a codebase. The suggestion is a draft, not an answer.</p>
<h2 id="what-are-the-honest-limits">What are the honest limits?</h2>
<p>No chat. No explanations. No multi-file edits. If a suggestion is wrong, you have to know enough to fix it, so it helps strong developers more than beginners.</p>
<p>Context is large but not magical. In a monorepo with 2,000 files, indexing takes a noticeable amount of time on first open and afterwards the most relevant files still win over distant ones. Cross-repo suggestions do not happen.</p>
<p>Language support is uneven. TypeScript, Python, Go, Rust and Java get strong completions. Niche languages and templating file types are weaker, which is why the settings table suggests disabling it for config formats.</p>
<h2 id="free-tier-versus-paid-in-practice">Free tier versus paid, in practice</h2>
<p>The free tier covers unlimited completions for individual developers, which is the whole product for most users. The paid Pro plan around $10/month adds team features and administrative controls, and longer context for large repositories.</p>
<p>For a solo developer the free tier is genuinely sufficient — an unusual situation in this category, and worth testing before assuming you need to pay.</p>
<h2 id="what-is-the-realistic-verdict">What is the realistic verdict?</h2>
<p>Set it up, use it for a week, and check two things: how often you accept a suggestion without editing it, and whether cross-file completions are actually better than your current tool&#8217;s. If acceptance is high, keep it. If you spend more time dismissing than accepting, the completion model does not fit your style and no setting fixes that.</p>
<h2 id="quick-summary">Quick Summary</h2>
<ul>
<li>Supermaven installs as a VS Code extension and works in about two minutes with GitHub sign-in.</li>
<li>It offers completions only: no chat, no agent, no test generation.</li>
<li>300,000-token context yields noticeably better cross-file suggestions than small-window tools.</li>
<li>Raise the suggestion delay to 100–150ms if ghost text feels noisy.</li>
<li>Word-by-word acceptance beats dismissing a long suggestion you half want.</li>
<li>Free tier is unlimited for individuals; Pro near $10/month adds team controls.</li>
</ul>
]]></content:encoded>
					
					<wfw:commentRss>https://www.iaifeed.com/how-to-set-up-supermaven-in-vs-code/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>
