DEV Community: Kadek Pradnyana

Introducing Eling: one memory shared across all your AI tools

Kadek Pradnyana — Sat, 03 Oct 2026 14:26:21 +0000

You've explained this before

You and ChatGPT picked Postgres for a new project three weeks ago. Today you open Cursor to write the schema, and it asks which database you're using.

You brainstorm a feature in Claude, then ask it to write a prompt for Claude Code so the next session knows the plan. You paste it into a fresh session and hope nothing got lost on the way.

You've told ChatGPT to keep answers short. Then Claude. Then Cursor. You try a new AI tool and spend the first session introducing yourself, your projects and the people you work with, all over again.

I run a software agency in Bali, and I lived this every day across Claude, ChatGPT, Cursor and Claude Code. If you use more than one AI tool, you probably do too.

Why it keeps happening

Memory lives inside each tool, and only there. What you teach Claude never reaches Cursor.

Built-in memory features help inside a single tool, but each one is a silo, and most are a black box: you can't easily see what was saved, correct what's wrong or take it with you when you switch tools.

So you become the glue. You carry context from tool to tool by hand, and every new chat costs you a few minutes of explaining.

The fix: one memory for all your AI tools

So I built Eling. It remembers what you tell your AI tools, so each of them knows you and your work, whichever one you open.

I feel it most when I move from brainstorming to building. I used to end every brainstorm in Claude by asking it to write a prompt for Claude Code. Now I open a new Claude Code session and start working. The decisions from the brainstorm are already there, so I don't generate handoff prompts or re-explain what needs to be done.

The problem	With Eling
A chat ends or runs out of room, and what you told it is gone	Eling keeps it for the next chat, next week and next year
You forget where a discussion ended	Ask, and your AI pulls the decision and the open questions
You plan in ChatGPT, and Cursor knows nothing	Open Cursor and it already knows the plan
You repeat "keep it short" in every tool	Say it once, and every connected tool follows
A new AI tool starts as a stranger	It knows your projects, people and preferences from the first chat
The same PDF gets uploaded to every tool	Attach it once, and any connected tool can search inside

You can also link people, projects and plans, and see how they connect in a graph.

How it works

Eling works inside the AI tools you already use. You set it up once.

Connect your AI tools. Add Eling to each tool as a connector. It takes about a minute per tool.
Talk as you always do. When you share a fact, a preference or a decision, your AI saves it to Eling. You can also ask it to remember anything else.
Every tool knows you. Start a conversation in any connected tool, and it recalls what matters, wherever you first said it.

Under the hood, Eling is a remote MCP server. Claude, ChatGPT, Cursor, Claude Code and other MCP clients connect to the same URL:

https://eling.io/mcp

If you build with agents

The problem gets worse with agents. You settle the plan in a brainstorm, then Claude Code, Cursor and your own agents each start without it. Eling gives every agent the same decisions, specs and rules, wherever the work started.

One brief for every agent. Decisions, specs and conventions are saved once, and Eling asks every connected agent to check them before it starts work.
Hand off between agents. One agent saves where it stopped and what's left. The next one, in any tool, picks up from there.
Your own agents too. Any MCP client that supports OAuth sign-in can connect, so the agents you build share the memory your tools use.

You stay in control

A memory you can't see is a memory you can't trust. Everything Eling keeps is yours to see, correct and take with you.

See everything. The Eling web app shows every memory, where it came from and what replaced what.
Correct and delete. Edit or delete any memory, and the change reaches every connected tool at once.
Take it with you. Export everything as Markdown or JSON whenever you like, and delete your account in one step.
Yours alone. Eling doesn't sell your data or use it to train AI models.

Try Eling

Eling is a Javanese and Balinese word for "to remember". It's built in Bali, so the name felt right.

Eling is in an invite-only beta, and it's free while the beta lasts. Join the waitlist at eling.io, and you'll get an email when your spot opens.

What's the one thing you're tired of explaining to your AI tools? Tell me in the comments.

How AI Automation Actually Changed Our Agency Workflow (From Someone Who Runs One)

Kadek Pradnyana — Wed, 13 May 2026 05:25:41 +0000

I've been writing code professionally for over a decade and I run a small agency out of Bali — UI/UX, development, digital marketing. Most posts I read about "AI and agency work" are either doom ("we're all cooked") or vendor pitches ("buy our platform"). Neither matches what I actually see day-to-day.

This is the version I wish someone had written for me two years ago.

What actually changed (and what didn't)

The honest summary: AI automation didn't replace agency work. It changed which parts of the work are valuable.

Here's the breakdown from inside our studio:

Compressed dramatically:

First-draft copy and content
Component scaffolding and boilerplate
Research synthesis (interview transcripts, competitor scans)
Performance reporting and dashboard prep
Initial UI variations and design exploration Barely moved:
Information architecture decisions
Edge-case handling in production code
Stakeholder alignment and discovery
Brand voice and creative direction
The judgment calls about what to build next If your role was 80% in the top bucket, you're feeling this hard. If your role was 80% in the bottom bucket, you're probably busier than ever — because the top bucket got cheap, so clients want more strategic work in the same engagement.

A concrete example: a marketing site rebuild

Two years ago, a typical marketing site rebuild for us:

Discovery:          1 week
Wireframes:         1 week
Visual design:      2 weeks
Frontend build:     2 weeks
QA + launch:        1 week
Total:              ~7 weeks

Same project today:

Discovery:          1 week    (unchanged — humans still talk to humans)
Wireframes:         2 days    (AI-assisted exploration, faster iteration)
Visual design:      1 week    (AI for variations, senior designer for direction)
Frontend build:     1 week    (Cursor + scaffolding, devs on edge cases)
QA + launch:        3 days    (automated visual regression, AI-assisted a11y review)
Total:              ~3 weeks

That looks like a 50%+ reduction in calendar time. It is — but the framing is misleading. We didn't fire half the team and pocket the difference. Two things happened:

We added scope inside the same engagement. More iterations, more A/B tests, more polish on the parts users actually touch.
We rebalanced senior vs. junior time. The "junior dev hammers out a navbar" hours mostly disappeared. The "senior dev figures out why this auth flow drops 12% of users" hours expanded. ## The stack that actually runs our work now

Skipping the buzzword versions. Here's what's in daily use:

Engineering side:

Cursor + Claude for component scaffolding and refactors
Custom internal AGENTS.md files per project so the AI has context on conventions
LibreChat as our internal AI gateway (auditable, multi-model, no data leak to consumer accounts)
Standard stack stays Node.js, Python, React, Go — none of that changed Design and content side:
AI for first-pass copy variations against tight briefs (briefs are the bottleneck, not the model)
Figma + AI plugins for repetitive layout work
Human-in-the-loop edit pass before anything reaches the client Ops side:
Automated weekly client reports pulled from analytics → drafted summary → strategist edits before send
AI-assisted intake forms that pre-qualify before discovery calls The pattern is consistent: AI handles volume, humans handle direction. Reverse that order and you ship garbage faster.

The four traps I see other agencies fall into

If you're evaluating an agency (or running one), these are the failure modes worth naming:

1. Treating AI as a margin grab

The agency cuts internal production time by 60% and keeps charging the same rates without expanding scope or improving outcomes. The client captures none of the benefit. This works for about one renewal cycle, then the client figures it out.

2. Automating broken processes

If your discovery process is broken, automating it produces broken discovery faster. AI is a multiplier on whatever's underneath it. Diagnose the process before you automate it.

3. Tool stacking without integration

I've seen agency pitches with 15+ AI tools listed. In practice, 13 of them aren't connected to each other and the team uses 3. What matters is reliable end-to-end workflows, not the size of the logo grid.

4. Removing the human-in-the-loop entirely

AI-generated content with no editorial pass is the agency equivalent of shipping console.log to production. It mostly works. Until it doesn't, very publicly.

The business model problem nobody's solved

This is the part I'm still actively figuring out, and I think most agency owners are too.

Traditional agency retainers are priced on time — N hours per month, defined scope. That model assumes time is the constraint. AI broke that assumption.

If we deliver in 10 hours what used to take 40, do we:

Option A: Charge for 10 hours at the old rate. (Client wins, we lose 75% of revenue on that engagement.)

Option B: Charge for 10 hours at 4× the rate. (Client revolts unless we can prove the outcome justifies it.)

Option C: Charge for the outcome. (Pipeline generated, conversion improved, ship date hit.)

We've moved selectively toward C on engagements where the outcome is measurable and we have enough signal to predict our ability to deliver it. It's better for clients. It's also significantly riskier for us — vague scopes don't protect anyone in outcome-based pricing.

For engineers thinking about freelancing or starting an agency in this environment: pick your pricing model early, and price the value, not the hours. The hours metric is becoming structurally misleading.

What this means for engineers inside agencies

If you're a developer working at an agency right now, the parts of your job that are most exposed are the most templated ones — landing pages with no novel state, CRUD admin panels, glue-code integrations. Those have been collapsing.

The parts that are less exposed are the ones that require holding the whole system in your head: API design that anticipates the next three features, refactors that don't break six other things, performance work, security review, debugging in production. None of that has gotten meaningfully cheaper.

Practical advice from inside the change:

Get fluent with AI tooling, but don't outsource your judgment to it. The senior engineers I see thriving treat AI like a fast junior dev — useful, needs supervision.
Push yourself toward the parts of the work that require system-level reasoning. That's where compensation is going.
Learn enough product and business to participate in scoping conversations. "I just build what's specced" is a shrinking job description. ## The takeaway

AI didn't kill agency work. It killed the cheap version of agency work.

What's left — and what's growing — is the part of the work that requires judgment, context, and ownership of outcomes. That's harder. It's also more interesting, and from where I'm sitting, more sustainable.

If you're an engineer wondering whether to stay at an agency, start one, or go in-house: the answer depends a lot on which side of the judgment / execution line you want to live on. AI shifted the line. It didn't erase it.

I run Lenka Studio, a small digital agency in Bali working with SMBs across AU/SG/CA/US. This post is adapted from the original essay on our blog.

GitHub Copilot Just Killed Flat-Rate AI Coding. Here's What It Means for Your Team.

Kadek Pradnyana — Thu, 30 Apr 2026 05:24:18 +0000

On April 27, 2026, GitHub announced that all Copilot plans are moving to usage-based billing on June 1, 2026. The flat "premium request" model is dead. Welcome to per-token pricing for AI coding assistants.

If you're a solo developer, this might not change much. If you run an engineering team, you need to read this carefully — because your AI bill is about to become unpredictable in ways it wasn't before.

Here's what's actually changing, why it's happening, and what you should do this month.

What's Changing

Today, Copilot uses Premium Request Units (PRUs). You get a monthly bucket of requests, and every chat or agent prompt counts as one — regardless of whether it's a one-line question or a 30-minute autonomous coding session.

Starting June 1, 2026:

PRUs are replaced by GitHub AI Credits (1 credit = $0.01 USD)
Every interaction is billed by token consumption — input + output + cached tokens
Each model has its own per-token rate, matching published API rates
Code completions and Next Edit suggestions remain free across all plans
Plan base prices are unchanged: Pro $10/mo, Pro+ $39/mo, Business $19/seat, Enterprise $39/seat
Each plan includes monthly AI Credits equal to its subscription price (Pro = $10 in credits, etc.)

The big shift: a quick question and a multi-hour agentic session no longer cost the same.

Why GitHub Did This

Read between the lines of the official announcement and the picture is clear. Agentic coding broke the math.

A single autonomous coding session — running across an entire repo, calling tools, iterating, retrying — can consume thousands of times more compute than a chat question. Under PRUs, both counted as "one request." A handful of power users can cost more than the plan price covers.

GitHub said it directly in their April 21 update on individual plans: "It's now common for a handful of requests to incur costs that exceed the plan price."

That's not sustainable. Token-based billing aligns price with cost. It's the same reason every API provider has always priced this way.

Who Wins, Who Loses

Wins: Developers who mostly use code completions and light chat. You'll likely see no real change. Your $10 Pro plan probably never came close to using $10 in tokens.

Loses: Heavy agent users. If you're running long-trajectory agentic workflows — multi-step refactors, autonomous bug-fixing across files, parallel subagents — you'll feel this. The same workflows that gave you outsized value under PRUs are exactly what's getting expensive.

Maybe: Teams. It depends entirely on how your developers actually use Copilot. Some companies will save money. Others will hit budget caps mid-month for the first time ever.

The Annual Plan Trap

If you're on an annual Pro or Pro+ plan, GitHub is doing something clever and slightly hostile: you keep your existing PRU-based pricing until the plan expires — but model multipliers go up on June 1 for annual subscribers only.

Translation: your existing annual plan gets quietly worse. You can either ride it out at degraded value, or convert to a monthly plan early and get prorated credit.

If you're an annual subscriber, you should sit down before June 1 and decide which path actually saves you money. Don't ignore this.

What To Do This Month

For individual developers:

Check your current usage. GitHub is launching a preview bill experience in early May. Look at your Billing Overview on github.com and see what your actual token consumption would have cost you the past few months.
Audit which models you use. Different models have wildly different per-token rates. If you're defaulting to the most expensive premium model for tasks GPT-5 mini could handle, that habit is about to cost real money.
Decide on annual vs monthly. If you're on annual, run the numbers before June 1.

For engineering teams:

Set up budgets. Admin-level budget controls let you cap spend at the enterprise, cost center, or user level. Use them. Without caps, one developer running parallel agent workflows can blow through your monthly credits in a week.
Pool credits across the org. GitHub now allows pooled included usage instead of per-seat isolation. This is genuinely useful — your light users effectively subsidize your heavy users without anyone changing behavior.
Educate your team on model selection. "Use the cheapest model that works for the task" is now a real engineering practice with a real budget impact.
Watch out for Copilot code review. It now consumes both AI Credits and GitHub Actions minutes. Two meters running at once.

The Bigger Picture

This isn't just a Copilot story. Every AI coding tool is heading the same direction — Cursor, Cody, Continue, Claude Code. Token-based pricing is becoming the default because flat-rate doesn't survive contact with agentic workloads.

The era of "$20/month gets you unlimited AI coding" is over. What's replacing it is more honest, but also more demanding: you need to know what your AI usage actually costs, and you need to manage it like any other infrastructure spend.

For teams that have been treating AI coding as a free productivity boost, that mental model needs to change before June 1.

The good news: the tools to manage this are getting better. Budget controls, usage dashboards, and pooled credits all help. The bad news: you actually have to use them.

Originally published on lenkastudio.com. We help teams ship modern web, mobile, and AI-powered products. If you're rethinking your AI dev tooling and budget for 2026, let's talk.