Most AI coding tools have the same problem: the AI only knows what’s in the file you have open. Ask Copilot why a function is broken and it’ll reason about the function in isolation, with no idea what calls it, what module it lives in, or what invariants the rest of the codebase assumes. That’s fine for boilerplate completion. It’s not fine when you’re debugging something that spans five files.
That’s the main thing I wanted to fix when I started QuillAI.
The Context Engine
The core idea is a wiki knowledge base. QuillAI crawls your entire project in the background, generates a Markdown page for every source file (summary, key symbols, dependencies, architectural notes) and injects relevant pages into every AI prompt. Combined with an AST-based repo map and a per-project FAQ layer, the AI has genuine context about your codebase rather than just the file you happen to have open.
~/.config/quillai/wiki/<project>/
context_engine.md
plugin_manager.md
repo_map.md
...
When you ask “how does the auth flow work?”, the context engine pulls the relevant wiki pages and feeds them into the prompt. The model isn’t guessing. It’s read the whole thing. The wiki updates automatically on save and on git commits, so it stays current without you thinking about it.
The FAQ layer sits on top of the wiki. As you work, QuillAI extracts how-to answers, architectural decisions, and codebase gotchas from your chat conversations and wiki pages, classifies them by type (howto, concept, decision, gotcha), and re-evaluates them when source files change. Stale entries get pruned. It’s a living knowledge base of things the AI learned about your project, fed back into every subsequent prompt.
Privacy First
The other thing I didn’t want was an editor that sends every keystroke to a cloud API. QuillAI connects to whatever backend you configure:
- Local (llama.cpp / Ollama): zero data leaves your machine, no API keys, works offline. I use
Qwen2.5-Coder-7Bon my dev box;Qwen2.5-Coder-32Bon the machine with real VRAM. - Claude, GPT-4, Gemini: full cloud power when you want it, one click in the status bar to switch
The status bar cycles through Local -> OpenAI -> Claude -> Gemini. If you’re on a local model and hit something that needs more reasoning, switching takes two seconds and switches back just as fast.
Agentic Mode
The chat panel isn’t just Q&A. QuillAI has a full agentic loop. The AI can investigate your codebase, read files, search for patterns, and apply changes autonomously.
When the AI suggests a code change, an apply bar appears below the response:
🔧 Replace function search_project()
📄 ai/context_engine.py ⚡ Apply to context_engine.py ↩ Undo
Single function replacements are AST-precise: only the target symbol is replaced, surrounding code is untouched. Full file rewrites open a side-by-side diff before writing anything. Multi-file changes get a unified review dialog where you can check or uncheck individual files before applying.
The agent loop uses a disciplined file editing approach I’ve found actually works in practice: check line count before reading, read the entire file before proposing changes, use write_file for small files rather than fragile string matching. All writes go through the diff dialog, which serves as the confirmation. No typing “yes, apply it.”
DevOps Features
I work with Ansible and GitLab CI daily, so those got native tooling.
Ansible Playbook Debugger: run ansible-playbook in the built-in terminal and QuillAI automatically parses the output into a live host×task matrix. Rows are tasks, columns are hosts, cells colored by status (ok/changed/failed/skipped). Click any cell to see full msg, stdout, stderr, and rc. When a task fails on some hosts but not others, a Compare Hosts button builds a prompt comparing their host variables. The 💡 Ask AI button sends the full error context directly to chat.
Visual CI/CD Pipeline Editor: open a .gitlab-ci.yml or GitHub Actions workflow and you get an interactive graph: job cards grouped into stage columns, dependency arrows between them. Drag a card to change its stage, drag between connection ports to add a needs: dependency, double-click to edit a job inline. Edits are surgical: only the specific lines that changed are touched, comments and anchors preserved.
Both of these are plugins, which brings me to the architecture.
Plugin System
QuillAI uses an auto-discovery plugin system. Drop a folder into plugins/features/ with a FeaturePlugin subclass and it loads on next launch with no changes to core code. Plugins communicate through a named event bus (file_opened, file_saved, project_opened, and more).
The features that make sense as plugins are plugins:
- Terminal (custom VT100 emulator)
- Import Graph: dependency visualization
- Symbol Outline: LSP-powered class/method tree
- Markdown Preview with scroll sync
- Context Debugger: visualize exactly what’s in the AI’s prompt
- Ansible Playbook Debugger
- Ansible Inventory Explorer
- SSH Host Manager
- Visual CI/CD Pipeline Editor
Individual plugins can be enabled or disabled at runtime from Settings without restarting. The terminal is built from scratch (VT100 parsing, ANSI colors, the works) because I wanted stderr capture to work reliably. When a command errors, a 💡 button appears in the status bar that sends the last 50 lines of output to chat.
LSP Integration
Nine language servers supported out of the box: Python (python-lsp-server), YAML/Ansible (yaml-language-server), JavaScript/TypeScript, Bash, HTML/CSS/JSON/Markdown, Nix (nil), Lua, Perl, and Terraform. Hover tooltips, Ctrl+Click go-to-definition, diagnostic squiggles, breadcrumb bar, symbol outline, rename with preview (F2).
None of this required writing a language server. It’s a generic JSON-RPC LSP client that routes to whatever server you have installed.
Editor
The editor itself has the things I’d miss if they weren’t there: split panes (horizontal and vertical, tabs drag between them), multi-cursor (Ctrl+D / Ctrl+Shift+L / column mode), minimap, git blame in the gutter, inline color swatches for hex values, crash recovery via silent autosave every two minutes.
Inline completions appear as ghost text at natural pause points. Tab accepts the full suggestion, Ctrl+Right accepts word by word. For files without an LSP server, Ctrl+Space opens an AI-powered completion popup ranked by the model.
Running It
# NixOS
nix run github:GSSparks/quillai
# AppImage (any Linux)
chmod +x QuillAI-*.AppImage && ./QuillAI-*.AppImage
# From source
git clone https://github.com/GSSparks/quillai
cd quillai
pip install PyQt6 requests pyyaml markdown chardet
python main.py
For NixOS there’s a flake that handles everything. For AppImages on NixOS you need appimage-run or programs.appimage.binfmt = true in your configuration.
Where It Is
It’s usable. I use it daily. The wiki generation, agentic loop, LSP integration, DevOps tooling, and plugin system all work. The roadmap has a few things I haven’t gotten to yet (test generation, infrastructure drift detection, completion feedback loop) but nothing that blocks day-to-day use.
The code is on GitHub. It’s MIT licensed.