Skip to main content

Jeikin with Cline

Connect Jeikin's MCP server to Cline so the agent that just edited fifteen files runs a WCAG check on every one of them before it stops. Every finding tracked, every fix verified.

Why connect Jeikin to Cline

Cline is the open-source autonomous coding agent that runs inside VS Code — read files, write files, execute commands, navigate the browser, all driven by a model of your choosing. The autonomy is the feature; it's also the risk. An agent that can edit fifteen files in a single turn can introduce fifteen accessibility regressions in a single turn.

Connecting Jeikin to Cline turns each autonomous step into a checkable step. The agent still moves fast, but it now stops to verify each change against the WCAG criteria your project actually has to meet, and it records what it did on the Jeikin dashboard.

Setup

In the project Cline is operating on, run:

npx jeikin

The CLI signs you in, creates or links a Jeikin project, and writes the MCP configuration into the Cline settings (Cline reads from the same mcp.json it uses for every other MCP server). Restart Cline's agent and the Jeikin tools appear in its available actions on the next task.

What changes when you connect

Cline's autonomy stops being open-ended on accessibility-relevant work. The first thing the agent does on any task that mentions accessibility, WCAG, review, audit, or a11y is get_started — it sets the project's conformance level and pulls the review guide.

During execution, every meaningful edit to a UI file is followed by a run_a11y_check. If the check fails, Cline iterates — applies the project's preferred pattern from fix_issue, re-checks, repeats until the criterion is satisfied. The dashboard accumulates findings via report_findings as the agent goes, so by the time the task completes, the audit trail already exists.

This pairs particularly well with Cline's plan/act mode separation. The plan now includes accessibility checks as explicit steps; the act phase verifies them.

Example: an autonomous component sweep

A representative task:

You: sweep src/components/forms/ and fix any accessibility issues.
     Use Jeikin to verify.

Cline (Plan): I'll walk every file in src/components/forms/, run a
              Jeikin review on each, and apply the project's fix
              pattern when issues are found. Each fix will be verified
              before I move on. Approve?

You: approve

Cline (Act): [calls get_started — project is WCAG 2.2 AAA]

             Reading 12 files...

             Walking InputText.tsx:
               - Missing visible focus indicator (2.4.7)
               [calls report_findings — #511]
               [calls fix_issue, applies focus-visible:ring-2 pattern]
               [calls run_a11y_check — pass]

             Walking InputEmail.tsx:
               - Missing autoComplete="email" (1.3.5)
               [calls report_findings — #512]
               [calls fix_issue, adds autoComplete]
               [calls run_a11y_check — pass]

             ... (continues through all 12 files)

             Summary: 8 issues found, 8 fixed, 0 open. All verified.
             Dashboard updated.

The dashboard shows 8 resolved issues, each with a timestamp, the file they were found in, and the criterion they satisfied. The fix commit references each one.

Common workflows

Continuous audit. Configure Cline as a scheduled task in your project — once a week, run the agent with a prompt like "audit any files modified since last week and report Jeikin findings." Issues accumulate on the dashboard between human reviews, so no one has to remember to re-audit.

Issue burn-down. Point Cline at the Jeikin dashboard: "fix every open issue tagged 'mechanical' for this project." It calls review_open_issues, filters, and walks the list autonomously. You review the resulting commit, not the individual edits.

Pattern migration. When the team adopts a new component pattern (e.g. switch from hand-rolled dialogs to Radix), Cline can apply the migration across the codebase and verify each migrated instance against the same criteria the old code was supposed to satisfy.

What Cline can and can't do with Jeikin

Can: operate across many files in a single task, call MCP tools between every step, report findings as it goes, verify fixes inline, and produce a coherent audit trail without manual intervention.

Can't: make subjective calls confidently. Cline is faster than most agents, which means it's faster at being wrong about meaning. Force a human-in-the-loop step for criteria that require judgement — alt-text content (1.1.1), heading specificity (2.4.6), error message helpfulness (3.3.3).

Won't: silently exceed scope. If you ask Cline to "fix the contact form" and it notices issues in the header, it leaves them as tracked findings rather than expanding the change set. The dashboard accumulates the work; the commit stays focused.

References