Ebig AI

Ebig AI brings Ebig's AI-powered development capabilities into VS Code.

Give Ebig AI a development task in plain words and it works in the project you have open: it searches and reads the code, edits or creates files, runs the project's own checks, fixes what the output shows, and reports what it changed and what it verified. You can also ask about the code in front of you, or get a selection explained or reviewed against your Ebig project's rules.

Requires an Ebig account and an Ebig project. The extension is free; it is a client for the Ebig platform you already use.

What you get

Ebig AI Chat

An Ebig AI container in the Activity Bar listing your saved conversations. Open one and it fills an editor tab — not a 300px sidebar. Ask a question, get an answer, keep the thread. The view shows when Ebig is working, lets you stop a running request, and shows exactly what is wrong when something fails.

The file you are in, its language and your current selection travel with the question, so you rarely have to paste code to be understood.

Give it a task (Dev)

Type the task into the chat, the way you would hand it to a colleague:

• Fix the list rendering bug in src/list.mjs and run the tests.
• Add a phone field to the signup form using the existing input components.
• The build of App/Admin fails — find out why and fix it.

Ebig AI reads the project's own instructions (AGENTS.md, CLAUDE.md, CONTRIBUTING.md, README.md near the files it touches — re-read at the start of each task, so edits to them apply to the next task), searches before it edits, and uses the build/test scripts it finds in your manifests. Dated reports (*-AUDIT*.md, CHANGELOG.md) and documents whose header says Status: historical/Hiệu lực: LỊCH SỬ are not used as instructions; they are only named, so Ebig AI can open them when a task needs history. Before the first command it already knows your OS and shell — on Windows PowerShell 5.1 it will not send &&, and it passes the working folder separately instead of cd.

While it works the chat shows the task's steps, each tool call and its result. Long command output is collapsed to its last lines; Open full output on the card opens the whole log in an editor tab.

Changed files are listed on the task strip — the files Ebig AI wrote with its file tools (files changed by a command it ran, such as a formatter, are not listed). Click one to open a diff against the file as it was before Ebig AI first wrote to it in this VS Code session, so edits you made before that are not mixed in. Edits you make to the same file while the task runs do show up in that diff — the diff is not an attribution record. After a VS Code restart the diff falls back to Git (changes since the last commit). Edits are written through VS Code, so Undo works.

Stop (the square button) stops scheduling new work and kills commands it is running. Files already written stay as they are; nothing is rolled back for you. Continue on the task strip — or typing continue — picks the work up again: after a Stop it starts a new task that carries the original request and the list of files already changed, and it re-reads their actual state before writing again.

The final report separates what was done, what was verified (with the command and its real result), what was not verified, and what is blocked. Under the report, Ebig AI adds two checks made by the extension, not by the model: path:line references are compared with the files on disk, and claims such as "build passed", "tests passed" or "edited x.js" are compared with the commands and writes that actually happened in the task — a claim with no matching evidence (or a build that ran before the last edit) is marked UNVERIFIED. Claims about UI or production testing are always UNVERIFIED: a Dev task cannot exercise either.

When you ask for a number ("how many places use X"), Ebig AI counts with search's count mode: matching files, matching lines and individual occurrences are reported separately, and the result says whether the count is complete — a timeout, too many files, or files it could not read make it explicitly partial. For a very long report Ebig AI is instructed to write it to a Markdown file under bao-cao/ and keep a summary and the path in the chat; the chat itself never cuts a report short.

What Ebig AI sends on each step. Each step sends the current state of the task: the request, any corrections you made, the plan, which files changed, and which checks ran with their exit codes. It does not resend the whole conversation. Long command output is sent as its error and warning lines plus the end of the output, along with an exact call Ebig AI can use to read the rest. You still see the full output. An earlier read of a file that has since been edited is replaced by a note to read it again, so Ebig AI never edits from stale content. The Ebig AI output channel logs the estimated context size of every call and the token usage the model reports. If the model does not report usage for a call, the total is marked as partial.

Explain Selection

Select code, right click → Ebig AI → Explain Selection.

You get what the code does, the role it plays, the logic step by step, the dependencies worth knowing, and any risk it carries. If something cannot be determined from the selection alone, you are told that instead of being given a guess.

Review Selection

Select code, right click → Ebig AI → Review Selection.

This is not a generic linter pass. The review is carried out against the rules and knowledge your Ebig project actually has — correctness, architecture, maintainability, security, performance, and UX where it applies. If a rule does not exist in your project, the review says so rather than inventing a standard to judge you against.

Project Context

Ebig answers inside a project. Ebig AI: Select Project sets which Ebig project this workspace belongs to, and the setting is stored per workspace — so opening a different customer's code does not carry the previous project's context with it.

Ebig AI: Select Agent lets you pin which Ebig agent answers. The list is read from your Ebig backend, and leaving it empty is the normal choice: Ebig decides which Skill applies, from your account, project and permissions.

Getting started

1. Install the extension.
2. Run Ebig AI: Login and sign in with your Ebig account.
3. Set your project when asked, or run Ebig AI: Select Project.
4. Open the Ebig AI icon in the Activity Bar and ask something.

Commands

Ebig authentication

Ebig AI uses your Ebig account. It does not create an account of its own and it does not hold a second set of credentials.

VS Code  →  Ebig login  →  Ebig account  →  access token  →  extension

Ebig AI: Login opens your Ebig login page and then asks for the access token, which is stored in VS Code SecretStorage — the same place VS Code keeps its own credentials. Ebig AI: Logout deletes it from this machine.

The token travels as Authorization: Bearer. Ebig verifies it; the extension never decodes, interprets or logs it.

Gateway-based architecture

Ebig AI is a client. It carries no model, no Skill table, no review rules and no knowledge base. All of that lives in Ebig, and which Skill answers you is decided there — from your account, project and permissions. For development tasks Ebig selects its Dev role; the extension adds only facts it measures on your machine (OS, shell, build/test scripts).

Before a development task starts, the extension asks Ebig which roles and machine capabilities it offers. If the backend has no Dev role, or lacks the basic capabilities (read, search, edit, create files, run a command, plan steps), no task is started and the chat says exactly what is missing. A sign-in or permission problem is reported as such, not as a missing capability. Pinning another agent in ebigAI.agent skips this check — that is ordinary Q&A, not a Dev task.

VS Code
  └── Ebig AI extension
        ├── account · authentication
        ├── editor context
        ├── chat UI
        └── API client
               │
               ▼
        Ebig Gateway  ──►  Ebig AI  ──►  Skill · Rule · Knowledge

Every request goes through Ebig Gateway, which authenticates the caller and confirms project membership before anything reaches the AI service. There is no second route, and the extension has no way to reach around it.

Settings

No setting holds a token, password or secret, and the build fails if one is ever added.

What leaves your machine

• For a question: the file name, its language, and the text you selected, capped by maxContextCharacters and visibly marked when truncated.
• For a task: the files and command output Ebig AI reads while working go to Ebig AI as tool results — one file or one search at a time, never a bulk upload of the repository. Secret files (.env, keys, credentials) are refused, secret- looking environment variables are stripped, and command output is redacted before it leaves.
• File paths are relative. An absolute path names your machine and often your customer; the extension sends src/api/client.js, not /Users/you/work/customer-a/src/api/client.js.
• Turn it off with ebigAI.sendOpenFileContext and only your typed question is sent.

Security

• Your credential stays in SecretStorage. Not in settings, not in workspace state, not on disk, not in logs, and never inside the chat view.
• The chat view cannot reach the network. Its content security policy declares connect-src 'none', so it physically cannot call out, and the credential is never handed to it.
• The credential never appears in an error message, including when a failing server echoes it back.
• AI output is inserted as text, never as HTML, behind a strict CSP with a fresh nonce for every render.

What it does on your machine, and when it asks

Tasks run inside the first folder of the open workspace. Paths outside it, symlinks that lead outside it, and secret files are refused by the tool layer.

• Runs without asking: reading, searching, creating, editing, moving and deleting files (deleted files go to the trash), local builds/tests/lint, local git (status, diff, commit, branch).
• Always asks first: git push/git pull, dependency changes, and any command that reaches the network or an external API — the dialog shows the exact shell, command and folder.
• A plan needs your approval before a multi-step task starts writing.

Every file write goes through one gate in the Execution Host, and every command runs as an explicit executable — there is no hidden shell between the approval and the command.

Support

Questions and problems: contact@ebig.vn · ebig.co

License

See the LICENSE file included with this extension.