DEV Community: Sulynn AI

DevWit v0.5.0: an open-source AI IDE with a transparent context panel (and a real editor)

Sulynn AI — Tue, 11 Aug 2026 03:09:11 +0000

DevWit is a free, MIT-licensed AI-native desktop IDE built around one principle: you should see exactly what the AI sees and does.

Every LLM request shows its full context — system prompt, tools, injected code / RAG hits / terminal output — with per-item token costs you can toggle off. Agent file writes and shell commands go through an authorization gate before they run.

What's new in v0.5.0

Editor productivity milestone (9 items):

Bracket pair highlighting + indent guides
Auto-pair brackets
Auto-indent / selection indent-outdent
Move lines, toggle line comment, duplicate line
Code folding + minimap

Built on top of v0.4.0 retention features: TypeScript + Python LSP, Git, DAP debugging, MCP servers, multi-agent orchestration, transparent RAG.

Why this exists

Most AI coding tools are black boxes. You don't see what got stuffed into the prompt, and agents can touch your files before you notice. DevWit makes both visible and enforceable — including a context manifest you can export as JSON for audit.

It's a standalone IDE (not a VS Code plugin) with a self-built editor kernel: piece-table buffer + Canvas rendering + tree-sitter.

Free, local-first

No accounts, no cloud sync, no paywall
Telemetry opt-in, off by default, zero content collected
Ollama keyless local models supported
Windows / macOS / Linux builds from public GitHub Actions

Links

GitHub: https://github.com/eeyzs1/DevWit
Release v0.5.0: https://github.com/eeyzs1/DevWit/releases/tag/v0.5.0

Feedback welcome — especially if you care about context hygiene or compliance-friendly agent workflows.

I shipped 7 AI tools in 2 months. Here's the boring code I kept rewriting.

Sulynn AI — Thu, 06 Aug 2026 06:07:40 +0000

I'm a solo dev. Over the past 2 months I built 7 small AI tools — a paper rewriter, an email generator, a resume optimizer, you get the idea. Different niches, same skeleton.

Every single time, I was rebuilding the same boring plumbing:

API key input + localStorage + show/hide toggle
Streaming output (SSE parsing, buffering, abort handling)
Responsive UI shell (header, hero, input/output panels)
SEO boilerplate (meta tags, Open Graph, JSON-LD)
Error mapping (401/402/429/network)

None of this is hard. It's just long. About 15 hours of work each time, mostly copy-paste from the last project with tweaks.

The pattern

API key management    → 2 hrs
SSE streaming + abort → 4 hrs
Responsive UI shell   → 6 hrs
SEO setup             → 2 hrs
Deploy + configure    → 1 hr
-------------------------
Total per tool        → 15 hrs

The actual "AI" part — defining modes, writing system prompts, picking a niche — was 30 minutes. The other 14.5 hours was infrastructure.

What I did about it

I distilled all of it into a single static boilerplate. No framework, no build step, no backend. One config.js file defines everything:

const CONFIG = {
  site: { name: 'My AI Tool', description: 'Powered by DeepSeek' },
  api: {
    endpoint: 'https://api.deepseek.com/v1/chat/completions',
    model: 'deepseek-chat',
  },
  modes: [
    { id: 'rewrite', label: 'Rewrite',
      prompt: 'Rewrite this text: {{input}}' },
    { id: 'expand', label: 'Expand',
      prompt: 'Expand this idea: {{input}}' },
  ],
}

That's literally the only file you touch. The engine handles API calls, streaming, UI, SEO, errors.

Why no framework?

I tried React. I tried Next.js. They're great, but for a single-purpose AI tool with one input and one output, they're overkill. You ship to GitHub Pages, you're done. No server costs, no cold starts, no Vercel limits.

The key insight: AI wrapper tools are static frontends. The API call goes browser → LLM directly. There's no backend to speak of.

What's included

API key management (localStorage, validation, auto-save)
SSE streaming with cross-chunk buffering and AbortController
Responsive UI (header, hero, config, panels, toast, status bar)
SEO (meta, Open Graph, Twitter Card, JSON-LD FAQ schema)
Config-driven engine (edit ONE file)
Zero-cost deploy (GitHub Pages, Vercel, Netlify, Cloudflare Pages)
Copy & toast, error handling, accessible markup

How I use it

Edit config.js (define modes, prompts, branding)
Push to GitHub
Enable GitHub Pages
Post on Reddit / Indie Hackers
Maybe add AdSense or affiliate links

Total time from idea to live: ~1 hour. Most of that is writing good prompts.

The honest part

This isn't a get-rich-quick thing. Each tool makes maybe $5-30/month in ad revenue or $0-2 sales. But building 10 of them with 15 hours each (150 hours total) vs. 10 hours total (1 hour each) — that's a 15x difference in shot count.

More shots = more chance one hits.

If you want to skip the 15-hour boilerplate and just build tools, I put the whole thing up at shipai.work. $199 one-time, lifetime updates.

But honestly — even if you don't buy it, the pattern is the takeaway: stop rebuilding infrastructure, start shipping products.

I built 7 AI tools, then realized I was doing it wrong. Here's what I learned.

Sulynn AI — Mon, 03 Aug 2026 07:33:25 +0000

I built 7 AI tool sites. A paper rewriter, a copywriter, a resume optimizer, a weekly report generator, an email generator, a meeting notes tool, and an AI navigation site.

Each one took me days to build. And each time, I was rebuilding the same infrastructure:

API key management (input, validation, localStorage)
SSE streaming (progressive output, abort, error handling)
Responsive UI (mode tabs, input/output panels, copy button)
SEO setup (meta tags, Open Graph, JSON-LD)
Deployment config (GitHub Pages, Vercel, etc.)

By tool #7, I realized: I was solving the same problems 7 times instead of solving them once.

The mistake

I thought I was building products. I was actually building infrastructure — over and over.

The actual "product" part of each tool — the prompts, the modes, the domain knowledge — was maybe 10% of the code. The other 90% was boilerplate I had already written for the previous tool.

What I did

I distilled the common code from all 7 tools into a single config-driven boilerplate called ShipAI.

The idea: edit ONE file (config.js), ship a new AI tool.

// config.js - this is the only file you edit
const CONFIG = {
  site: { name: 'My AI Tool', description: '...' },
  api: { endpoint: 'https://api.deepseek.com/v1/chat/completions' },
  modes: [
    { id: 'rewrite', label: 'Rewrite', prompt: 'Rewrite: {{input}}' },
    { id: 'expand', label: 'Expand', prompt: 'Expand: {{input}}' },
  ],
}

That's it. The boilerplate handles:

API key input + validation + localStorage
SSE streaming with abort + error handling
Responsive UI (Tailwind, no build step)
SEO template (meta, OG, JSON-LD)
Copy button, loading states, empty states

Pure frontend. No backend, no servers, no npm install. Deploy to GitHub Pages for free.

What I learned studying successful indie hackers

After building 7 tools that nobody used, I studied every verifiable indie hacker success story I could find:

Pieter Levels (@levelsio): 70+ projects, 95% failed. Ships in days, not weeks. PHP + jQuery (not fancy frameworks).
Marc Lou (@marclouvion): 30 failed projects before ShipFast ($249) took off. Now $100K+/month with 16 products.
Filip Panoski: Failed 5 times. Learned B2B > B2C, subscription > one-time, validate with waitlist BEFORE coding.

The pattern was clear: they all built audiences BEFORE products, not the other way around.

I did it backwards. I built 7 products with zero audience. This time, I'm doing it right — building in public from day one.

What's next

Ship the boilerplate ($199 one-time, inspired by ShipFast)
Build in public — share revenue, failures, process
Launch more products for indie devs
Cross-promote

Day 1. Revenue: $0. Followers: 0. Let's see what happens.

If you're building AI tools, check out ShipAI. It might save you the 7 failed attempts it took me to learn these lessons.

This is part of my build-in-public journey. I'll share updates as I go — the good, the bad, and the $0 revenue reports.

I built an AI IDE that shows you exactly what it sends to the model

Sulynn AI — Wed, 29 Jul 2026 05:00:32 +0000

Every AI coding tool asks for the same leap of faith: trust that the context it
sends is reasonable, and trust that the agent won't touch anything it
shouldn't. I got tired of leaps of faith, so I built
DevWit — a free, open-source AI IDE where
both are fully visible and enforceable.

The two walls I kept hitting

Wall 1: opaque context. The model's answer degrades, and you can't tell
why. Was a 40k-token file silently injected? Did a stale RAG chunk crowd out
the file you actually care about? Most tools treat the prompt as a black box.

Wall 2: ambient authority. Agents that can write files and run shell
commands are genuinely useful — right up until one does something you didn't
expect. "It mostly asks first" is not a permission model.

DevWit's answers to these two walls are its core features.

Feature 1: The Context Panel

Every LLM request in DevWit renders a complete manifest before it's sent:

The system prompt (per-mode, editable)
The tool list
Every injected item — files, RAG chunks, terminal output, diagnostics — each with its own token count

Any item can be toggled off, per request. Cut a noisy retrieval result and you
watch the token total drop in real time. After the request, the manifest is
written to disk, so "what exactly did the model see when it produced this
diff?" is an answerable question — weeks later, in an audit, if needed.

The codebase index (RAG) follows the same rule: retrieval hits appear as
individual, labeled items in the manifest, and if nothing was injected, the
panel says why (index disabled / still building / no hits / provider
doesn't support embeddings). No silent failures.

Feature 2: The Authorization Gate

The agent runtime physically cannot write a file or execute a shell command
without a per-action approval. The gate shows the exact operation — file path
or full command line — and you approve, reject, or remember the decision for
the project.

This isn't a system-prompt promise. The tool execution path routes through an
authorizer; without a recorded approval the call doesn't happen. MCP tool
servers get the same treatment: every external tool call goes through the gate
under its fully-qualified name.

Feature 3: Lean context by routing

More context isn't better context. DevWit includes a task router that
classifies each request: simple ones (typo fixes, small questions) go to a
local model via Ollama — free, private, offline-capable — while complex
multi-file work goes to your configured cloud model (Anthropic or any
OpenAI-compatible API). A per-session usage ledger tracks tokens and estimated
cost, so the routing decision is auditable too.

It's a real IDE, not a chat wrapper

Under the AI features is a daily-driver editor:

TypeScript language server — live diagnostics, hover, go-to-definition
Integrated Git — status badges in the file tree, stage/commit, inline diff
Breakpoint debugging — DAP via js-debug: breakpoints, stepping, variable inspection
Multi-agent orchestration — a planner mode decomposes intent into parallel sub-agents with per-agent activity streams
Custom modes — define your own system prompt / tool set / model / context policy per mode, hot-reloaded, shareable as JSON
MCP tool servers — stdio servers managed from settings, lifecycle handled on quit

Engineering honesty

v0.3.0 is verified by 614 unit tests and 28 end-to-end suites that drive
the real packaged app (not mocks). Ships for Windows (NSIS), macOS (dmg/zip),
and Linux (AppImage/deb), with auto-update from GitHub Releases.

What it deliberately does not have: accounts, cloud sync, a marketplace,
or any paywall. Telemetry is opt-in, off by default, anonymous, and collects
zero content — the endpoint is configurable if you'd rather self-host
PostHog. It's free software, and it will stay that way.

What's next

The near-term roadmap is trust and reach: Azure Trusted Signing for Windows
builds (infrastructure is already in CI, waiting on my account), winget
distribution (PR under review), then deeper LSP language coverage.

If you work on a team with compliance requirements — or you simply want to
know what your AI tools are doing — I'd genuinely love your feedback.

Links: GitHub ·
Releases