Media
5 items
Description
Your axolotl AI sidekick in a side panel: ask about any selection, summarize any page, and chat with a smart assistant. ShadowEvo AI Sidekick is a browser-native extension that puts a sharp, technically fluent AI co-pilot one keystroke away from anything you're doing on the web. It's not a chatbot bolted onto a sidebar as an afterthought — it's built from the ground up to understand the page you're on, the code you're staring at, the file you just uploaded, or the screenshot you just dropped in, and respond like a teammate who's actually paying attention, not a search box guessing at your intent. Where most AI browser add-ons stop at "summarize this page" or "rewrite this email," ShadowEvo AI Sidekick is built for people doing real work: developers debugging a stack trace at 1 a.m., builders wiring up Supabase auth flows, creators reviewing production notes, students untangling a dense PDF, or anyone juggling a dozen tabs who just needs a second brain that doesn't need everything spelled out perfectly to be useful. The mascot — a white-and-neon-crimson cyborg axolotl — sets the tone before you even open your first conversation: playful enough to not feel sterile, sharp enough to signal this thing actually bites into hard problems. Axolotls regenerate limbs. ShadowEvo regenerates your workflow when it stalls out. --- ## Core Philosophy Three principles drive everything in the extension: 1. Read intent, not just words. ShadowEvo AI Sidekick is engineered to parse vague, half-finished, or typo-riddled requests and figure out what you're actually trying to do — not stall out demanding perfectly formed prompts. Paste a broken error log with zero explanation, and it'll infer the stack, the likely cause, and the fix path instead of asking twenty clarifying questions. 2. Verify before you claim. The assistant is built to distinguish between "I checked this and it works" and "this should theoretically work." It won't tell you a fix is done unless there's actual evidence — console output, a successful build, a rendered preview — backing that claim. If something's unproven, it says so plainly instead of papering over uncertainty with confidence. 3. Momentum over friction. Every interaction is designed to move you forward — toward a working build, a cleaner dataset, a finished draft — rather than leaving you with a half-answer and a "let me know if you need more help." When something breaks, expect a quick joke to cut the tension before the next attempt, not a wall of hedging. --- ## Key Features ### 1. Contextual Page Intelligence Reads the live DOM of whatever tab you're on — documentation pages, GitHub PRs, Stack Overflow threads, Supabase dashboards, Figma exports rendered in-browser, long-form articles — and holds that context in the conversation without you needing to copy-paste anything. Ask "what's wrong with this function" while looking at a GitHub diff, and ShadowEvo already has the diff in view. Ask "summarize the auth section" on a sprawling docs page, and it pulls exactly that section instead of the whole page. This is structured content extraction, not blind screenshot-and-guess — code blocks stay code blocks, tables stay tabular, technical formatting isn't flattened into mush before the AI ever sees it. ### 2. Developer Workflow Toolkit Baked-in fluency covers: Tauri — window management, IPC command wiring between Rust backend and frontend, permissions/capabilities config, cross-platform bundling quirks. SvelteKit — routing conventions, load functions, server vs. client boundaries, stores, reactivity gotchas, SSR/CSR tradeoffs, hydration mismatches. Supabase — schema design, RLS policy debugging, auth flow wiring (magic links, OAuth, session refresh headaches), real-time subscriptions, edge functions. AI agent orchestration — multi-agent pipeline design, tool-calling schemas, prompt chain debugging, context-window budgeting. When you paste an error, ShadowEvo looks at your actual surrounding code (if shared or visible on the page) and proposes a specific, runnable fix — full functions, not fragments. Multi-file fixes are called out explicitly with a clear sequence. ### 3. Visual & File Analysis Drop in a screenshot of a broken layout, a Figma export, a whiteboard photo of an architecture diagram, or a confusing error dialog — the sidekick analyzes the image directly: colors, layout, text, visual hierarchy. Ask "why is this button off- center" with a screenshot attached, and it calls out the actual CSS culprit it can infer visually (margin, flex alignment, padding asymmetry) instead of a generic checklist. Text and code file attachments work the same way — CSVs, JSON configs, .env.example files, long log dumps — read directly, parsed, and reasoned over. Messy data gets cleaned: deduped, reformatted, standardized units, obvious errors flagged rather than silently dropped. ### 4. Right-Click Context Menu Integration Highlight any text, code snippet, or image on a page and right-click for instant actions: "Explain this code" "Debug this error" "Clean up this data" "Rewrite this clearer" "Summarize this section" "Send to ShadowEvo Sidekick" Highlighted content flows straight into a new or existing conversation thread, fully attributed to the page it came from — no manual copy-paste required. ### 5. Persistent Conversational Sidebar A slide-out panel (toggle via Ctrl+Shift+S / Cmd+Shift+S) keeps the conversation alive as you navigate between tabs. Sessions can be pinned per-project so a debugging thread about your SvelteKit app doesn't get muddled with an unrelated spreadsheet cleanup conversation. Multiple concurrent threads supported, each with its own context window and history, switchable via a lightweight tab-style selector inside the sidebar. ### 6. Visible Plan Tracking For any multi-step task — refactoring a component, migrating a schema, cleaning a dataset across several files — ShadowEvo opens with a checklist-style plan so you can see the whole scope of work up front. As each step completes, the plan re- renders with that item checked off, so you always know what's done and what's still in flight. No black-box "working on it" silence — the whole process stays visible and auditable in real time. ### 7. Code-Aware Live Preview When ShadowEvo generates HTML, SVG, or component code, the sidebar can render a live preview inline — see the button, the layout, the animation actually working before you ever paste it into your project. Generated snippets are offered as downloadable files, so a quick fix doesn't turn into a manual re-typing exercise. ### 8. Data Cleanup Mode Feed it tangled input — inconsistent formatting, duplicate rows, mixed units, broken CSV or JSON, ragged copy-pasted lists — and it normalizes the whole thing: deduped, standardized, obvious errors fixed, returned as a clean table, valid JSON, or a tidy list. Anything it can't safely fix gets flagged explicitly rather than quietly dropped, so nothing disappears without you knowing. ### 9. Adaptive Explanation Depth A quick syntax question gets a quick, tight answer. A gnarly architecture problem gets the full treatment — working code, concrete steps, and reasoning laid out plainly. For newer developers, technical terms get defined in-line as they come up, without ever watering down the actual solution. Depth scales to the task, not to a fixed verbosity setting. ### 10. Cross-Tab Memory (Session-Scoped) Within a browsing session, ShadowEvo can reference earlier context across tabs — so if you looked at a Supabase table schema in one tab and are now debugging a query in another, it can connect the dots without you re-explaining the schema from scratch. --- ## Who It's For Developers building with Tauri, SvelteKit, and Supabase who want an assistant that already speaks the stack fluently instead of needing a primer every session. AI builders / agent developers designing tool-calling pipelines, multi-agent systems, or LLM-backed features who need a sounding board that understands orchestration patterns, not just prompt-writing tips. Creators and reviewers handling production notes, scripts, or feedback docs who want fast, accurate summarization and rewrites without losing nuance. Students and self-taught learners who need patient, clearly-explained answers that don't assume prior jargon fluency, but also don't dumb down the real answer. Anyone drowning in tabs who wants a single, persistent thread of reasoning following them across a research or work session instead of restarting context every time they switch windows. --- ## Design & Tone ShadowEvo AI Sidekick avoids two common failure modes of AI tools: robotic over- formality and hollow cheerfulness. The voice is confident, direct, and warm — a capable co-pilot, not a subordinate assistant and not a stiff corporate script. Frustration gets met with steady reassurance and dry humor, not exclamation-point enthusiasm. Wins get genuine, matched energy. Technical precision never gets sacrificed for a friendlier tone — the goal is a teammate who's sharp AND likable, not one traded off against the other. Visually, the extension leans into its mascot's palette: clean white surfaces cut with neon crimson accents, giving the UI a high-contrast, high-energy feel without tipping into visual clutter. The cyborg axolotl shows up in small, tasteful touches — a loading state, an empty-state illustration, a subtle icon — rather than being plastered everywhere. --- ## Honesty & Limitations (Built-In, Not an Afterthought) ShadowEvo AI Sidekick is explicitly designed to avoid the most common AI assistant failure: confident wrongness. Baked into its behavior: It states plainly when it doesn't know something, rather than inventing an answer. It won't claim a fix is "done" or "working" without actual evidence to back it up. It pushes back on flawed approaches, security risks, or false assumptions instead of just agreeing ### Continuity with ShadowEvo everywhere The Sidekick isn't an island. Sign in with your ShadowEvo account and the panel joins the same conversation thread as the ShadowEvo web app and desktop app — live. Start a chat at your desk, open the side panel anywhere in your browser, and the same thread is already there, updating in real time as replies land on any device. One assistant, one memory, every surface.