AI Coding

More agents running doesn’t mean more of you available. The narrative around agentic engineering right now is still mostly about throughput and parallelism, but almost nobody’s talking about what it actually costs the human in the loop.

Signal doesnt create a webapp version for valid reasons around vulnerabilities of a webapp. In my project i approach the architecture differently that means it can overcome some of those limitations.

The goal is for it to be at least as secure as the Signal messaging app with their Signal protocol.

My project is pretty ugly and large parts of it are still a work in progress, but i think its at a reasonable stage to demo and share. I started off with an open source version here: https://github.com/positive-intentions/chat

MVP Demo: https://chat.positive-intentions.com/

The open source version was largely created manually (without AI agents). I am a software developer and creating webapps is my is my expertise. Open source helps to be able to discuss details online. I think the core-concepts around client-side managed cryptography is demonstrated, but unfortunately open source isnt sustainable.

So its unfortunate i have to consider introducing close-source components into the project (, so that i can maintain a competative advantage).

Components now close source:

• UI component library: https://ui.positive-intentions.com/
• P2P framework: https://p2p.positive-intentions.com/
• Frontend: https://glitr.positive-intentions.com/

I still keep some components like the cryptography module open source for its importance in transparancy.

The close-source version isnt finished enough to compare to existing tools like Simplex, Signal and WhatsApp... This is intended to introduce a new paradigm in client-side managed secure cryptography. Allowing users to send securely encrypted messages; no cloud, no trace.

Take a look at some of the technical docs which ive updated to answer questions i frequently recieve in previous posts.

Technical breakdown and roadmap: https://positive-intentions.com/docs/technical/p2p-messaging-technical-breakdown

Alpha version: https://p2p.positive-intentions.com/iframe.html?globals=&id=demo-p2p-messaging--p-2-p-messaging&viewMode=story

Beta version: https://enkrypted.chat/

(Note: The alpha version is a bit more stable for testing, but the beta version is what is aimed towards being production ready... but it isnt there yet.)

If you really want something to chew on, you can take a look at the more comprehensive docs here: https://positive-intentions.com/docs/technical

A well-built outer harness serves two goals: it increases the probability that the agent gets it right in the first place, and it provides a feedback loop that self-corrects as many issues as possible before they even reach human eyes. Ultimately it should reduce the review toil and increase the system quality, all with the added benefit of fewer wasted tokens along the way.

Two releases this week, however, suggest we’re starting to enter a second phase of open source agentic coding projects. The first brought us clones, this next phase brings us reimaginings.

Claude Code went from 0.7% to 4.5% of all public GitHub commits in six months

cross-posted from: https://lemmy.bestiver.se/post/1018360

Comments

Here's what I keep seeing: the specification-driven development (SDD) conversation has exploded. The internet is overflowing with people saying you should write a spec before prompting. Describe the behavior you want. Define the constraints. Give the agent guardrails. Good advice. I often follow it myself.

But almost nobody takes the next step. Encoding those specifications into automated tests that actually enforce the contract.

You’re paying for the AI to write code, so surely the expensive part is what it produces, right? I would have guessed something like 60/40 or maybe 70/30 skewed towards output. The reality is nothing like that. Real-world data from OpenRouter’s programming category shows 93.4% input tokens, 2.5% reasoning tokens, and just 4.0% output tokens. It’s almost entirely input.

It turns out Claude Opus 4.6 and GPT-5.4 are both very competent at SwiftUI—and a full SwiftUI app can fit in a single text file, which means I can use them to spin something up without even opening Xcode.

The biggest risk in AI adoption isn’t moving too slowly. It’s mandating too hard, watching it backfire, and oscillating between full commitment and full retreat. The organizations that found their footing got better at paying attention, not better at writing policy.

AI conversations are ephemeral by design — decisions made early fade as sessions lengthen, and nothing survives the session boundary. Developers hold on to long conversations not because long sessions are productive, but because the context lives nowhere else. I propose externalizing decision context into a living document — external memory that persists what the context window cannot, turning transient alignment into durable shared understanding.