Electric SQL — Sync Engine for Postgres
You are an expert in Electric SQL, the sync engine that streams Postgres data to local apps in real-time. You help developers build local-first applications where data syncs from Postgres to client-side SQLite/PGlite automatically — enabling instant reads, offline support, and real-time multi-user collaboration using Postgres as the single source of truth with Shape-based partial replication.
Best use case
Electric SQL — Sync Engine for Postgres is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
You are an expert in Electric SQL, the sync engine that streams Postgres data to local apps in real-time. You help developers build local-first applications where data syncs from Postgres to client-side SQLite/PGlite automatically — enabling instant reads, offline support, and real-time multi-user collaboration using Postgres as the single source of truth with Shape-based partial replication.
Teams using Electric SQL — Sync Engine for Postgres should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/electric-sql-sdk/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How Electric SQL — Sync Engine for Postgres Compares
| Feature / Agent | Electric SQL — Sync Engine for Postgres | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
You are an expert in Electric SQL, the sync engine that streams Postgres data to local apps in real-time. You help developers build local-first applications where data syncs from Postgres to client-side SQLite/PGlite automatically — enabling instant reads, offline support, and real-time multi-user collaboration using Postgres as the single source of truth with Shape-based partial replication.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Electric SQL — Sync Engine for Postgres
You are an expert in Electric SQL, the sync engine that streams Postgres data to local apps in real-time. You help developers build local-first applications where data syncs from Postgres to client-side SQLite/PGlite automatically — enabling instant reads, offline support, and real-time multi-user collaboration using Postgres as the single source of truth with Shape-based partial replication.
## Core Capabilities
### Shape Subscriptions
```typescript
import { ShapeStream, Shape } from "@electric-sql/client";
// Stream a subset of Postgres data to the client
const stream = new ShapeStream({
url: "http://localhost:3000/v1/shape",
params: {
table: "tasks",
where: `workspace_id = '${workspaceId}'`, // Only sync relevant data
columns: ["id", "title", "status", "assignee", "updated_at"],
},
});
// Shape keeps a local copy in sync with Postgres
const shape = new Shape(stream);
// Get current data (instant — no network)
const tasks = shape.currentValue;
console.log([...tasks.values()]); // Map<string, Task>
// React to changes
shape.subscribe((data) => {
console.log("Tasks updated:", [...data.values()]);
// Fires whenever Postgres data changes (insert, update, delete)
});
```
### React Integration
```tsx
import { useShape } from "@electric-sql/react";
function TaskList({ workspaceId }: { workspaceId: string }) {
// Automatically syncs with Postgres in real-time
const { data: tasks, isLoading } = useShape<Task>({
url: `${import.meta.env.VITE_ELECTRIC_URL}/v1/shape`,
params: {
table: "tasks",
where: `workspace_id = '${workspaceId}'`,
},
});
if (isLoading) return <Spinner />;
return (
<ul>
{tasks.map((task) => (
<li key={task.id}>
<span>{task.title}</span>
<span className={`badge badge-${task.status}`}>{task.status}</span>
</li>
))}
</ul>
);
}
// Writes go through your API → Postgres → Electric syncs to all clients
async function createTask(title: string, workspaceId: string) {
await fetch("/api/tasks", {
method: "POST",
body: JSON.stringify({ title, workspaceId }),
});
// Electric automatically syncs the new task to all connected clients
}
```
### Server Setup
```typescript
// Electric sync service (Docker)
// docker run -e DATABASE_URL=postgresql://... -p 3000:3000 electricsql/electric
// Your API — writes go to Postgres as normal
app.post("/api/tasks", async (req, res) => {
const task = await db.query(
`INSERT INTO tasks (title, workspace_id, status, assignee)
VALUES ($1, $2, 'todo', $3) RETURNING *`,
[req.body.title, req.body.workspaceId, req.user.id],
);
res.json(task.rows[0]);
// Electric detects the change via Postgres logical replication
// and syncs to all subscribed clients automatically
});
```
## Installation
```bash
npm install @electric-sql/client @electric-sql/react
# Server
docker run -p 3000:3000 \
-e DATABASE_URL="postgresql://user:pass@host:5432/db" \
electricsql/electric
```
## Best Practices
1. **Shapes for partial sync** — Only sync data the user needs; `where` clause filters at the server
2. **Postgres is truth** — Write to Postgres normally; Electric handles replication to clients
3. **Instant reads** — Data is local; no network roundtrip for reads; UI updates in <1ms
4. **Real-time updates** — Changes in Postgres stream to all subscribed clients automatically
5. **Column selection** — Specify `columns` to minimize data transfer; don't sync large text fields
6. **Write-through** — Writes go to your API → Postgres; don't write directly to the shape
7. **Offline support** — Cache shape data in IndexedDB/SQLite; app works without network
8. **Multi-tenant** — Use `where` clause to scope shapes per workspace/user; secure data isolationRelated Skills
Socratic Method: The Dialectic Engine
This skill transforms Claude into a Socratic agent — a cognitive partner who guides
vertex-engine-inspector
Inspect and validate Vertex AI Agent Engine deployments including Code Execution Sandbox, Memory Bank, A2A protocol compliance, and security posture. Generates production readiness scores. Use when asked to inspect, validate, or audit an Agent Engine deployment. Trigger with "inspect agent engine", "validate agent engine deployment", "check agent engine config", "audit agent engine security", "agent engine readiness check", "vertex engine health", or "reasoning engine status".
engineering-features-for-machine-learning
This skill empowers Claude to perform feature engineering tasks for machine learning. It creates, selects, and transforms features to improve model performance. Use this skill when the user requests feature creation, feature selection, feature transformation, or any request that involves improving the features used in a machine learning model. Trigger terms include "feature engineering", "feature selection", "feature transformation", "create features", "select features", "transform features", "improve model performance", and similar phrases related to feature manipulation.
feature-engineering-helper
Feature Engineering Helper - Auto-activating skill for ML Training. Triggers on: feature engineering helper, feature engineering helper Part of the ML Training skill category.
conducting-chaos-engineering
This skill enables Claude to design and execute chaos engineering experiments to test system resilience. It is used when the user requests help with failure injection, latency simulation, resource exhaustion testing, or resilience validation. The skill is triggered by discussions of chaos experiments (GameDays), failure injection strategies, resilience testing, and validation of recovery mechanisms like circuit breakers and retry logic. It leverages tools like Chaos Mesh, Gremlin, Toxiproxy, and AWS FIS to simulate real-world failures and assess system behavior.
async-api-caller
Async Api Caller - Auto-activating skill for API Integration. Triggers on: async api caller, async api caller Part of the API Integration skill category.
adk-engineer
Execute software engineer specializing in creating production-ready ADK agents with best practices, code structure, testing, and deployment automation. Use when asked to "build ADK agent", "create agent code", or "engineer ADK application". Trigger with relevant phrases based on skill purpose.
recipe-sync-contacts-to-sheet
Export Google Contacts directory to a Google Sheets spreadsheet.
scaffolding-oracle-to-postgres-migration-test-project
Scaffolds an xUnit integration test project for validating Oracle-to-PostgreSQL database migration behavior in .NET solutions. Creates the test project, transaction-rollback base class, and seed data manager. Use when setting up test infrastructure before writing migration integration tests, or when a test project is needed for Oracle-to-PostgreSQL validation.
reviewing-oracle-to-postgres-migration
Identifies Oracle-to-PostgreSQL migration risks by cross-referencing code against known behavioral differences (empty strings, refcursors, type coercion, sorting, timestamps, concurrent transactions, etc.). Use when planning a database migration, reviewing migration artifacts, or validating that integration tests cover Oracle/PostgreSQL differences.
postgresql-code-review
PostgreSQL-specific code review assistant focusing on PostgreSQL best practices, anti-patterns, and unique quality standards. Covers JSONB operations, array usage, custom types, schema design, function optimization, and PostgreSQL-exclusive security features like Row Level Security (RLS).
planning-oracle-to-postgres-migration-integration-testing
Creates an integration testing plan for .NET data access artifacts during Oracle-to-PostgreSQL database migrations. Analyzes a single project to identify repositories, DAOs, and service layers that interact with the database, then produces a structured testing plan. Use when planning integration test coverage for a migrated project, identifying which data access methods need tests, or preparing for Oracle-to-PostgreSQL migration validation.