Last weekend I began work on a new experiment called Aethralink, a system designed to make links verifiable. This weekend I’m reporting back on what has been built, what’s working, and what’s still being shaped. The goal hasn’t changed: to create a verifiable shortlink that can prove where it came from and that it hasn’t been altered. It sounds simple, but building proof into something as lightweight as a URL has turned out to be both fascinating and unexpectedly complex.
Over the past week, I’ve refined the system’s foundation and focused on how each shortlink carries its own cryptographic proof. The process is now working end to end. You can create a link, sign it, and have it independently verified. Behind that simplicity is a full identity layer built on decentralized identifiers (DIDs) and verifiable credentials (VCs). Each link can confirm its source without asking anyone’s permission. That part still amazes me.
Hybrid Cryptography and the Future of Verification
The biggest step forward came from introducing hybrid cryptography. Aethralink now supports both Ed25519 and Dilithium5, which means each shortlink can verify itself under classical, post-quantum or a hybrid of both security standards. This isn’t about presentation or polish; it’s about making the system resilient enough to endure. The day will come when today’s encryption can no longer protect what we build. I want these shortlinks to survive that day.
This stage of the project bridges traditional cryptographic methods with the emerging mathematics of post-quantum security. Ed25519 represents the elegant speed of modern elliptic curves. Dilithium5, in contrast, belongs to the emerging post-quantum standard approved by NIST. Combining them means the system can be verified across both generations of cryptography. The idea is simple: proof that survives time.
That principle defines more than the algorithmic layer. It extends to how the data is stored, retrieved, and verified. Each shortlink includes a verifiable credential that travels with it. Verification becomes a property of the data itself, not of the platform hosting it.
Why PostgreSQL Still Matters in Web3
The database structure behind Aethralink uses PostgreSQL 17, which might seem like an odd choice for a Web3 service. Many assume decentralization requires abandoning traditional databases altogether. But the truth is more nuanced. The system uses PostgreSQL for performance and reliability while still preparing to integrate with decentralized storage through Ceramic ComposeDB.
This hybrid approach offers the best of both worlds: speed locally and persistence across the network. Shortlinks resolve in under a hundred milliseconds when cached, yet every credential can later sync with a decentralized record. In a world obsessed with decentralization, it is easy to forget that reliability still matters.
Aethralink treats decentralization as a continuum, not a binary switch. Some data belongs close to the user. Some belongs distributed. The art is knowing which is which.
Refactoring for Stability
One of the quieter but more meaningful updates this week was refactoring the configuration system. The hardcoded values have been moved into the database so that everything can be managed safely without changing the code itself. It’s the kind of change that goes unnoticed because it doesn’t alter what the user sees, but it completely changes how stable the system feels to work on.
This refactor means configuration can evolve cleanly, version by version, without risk of breaking the application. It also allows for something deeper: transparency. Every configuration change is now auditable. In systems that aim to prove their own truth, that traceability matters. Quiet progress, but the kind that lasts.
AI in the Loop: Behavior as Specification
Behavior-driven development (BDD) remains the backbone of everything. Each feature starts as a Gherkin story, written in plain English before the first line of code exists. It’s a method that turns behavior into a form of contract.
AI now plays a collaborative role in this process. The models help expand, refactor, and suggest scenarios, but they don’t define the intent. The human intent stays central. The AI is useful for consistency and coverage, but the ethics, what counts as acceptable behavior, are still decided by people.
When a test passes, it feels less like a technical event and more like a moral one. Each passing scenario means another small promise has been kept. It is accountability expressed in logic.
This project has been a personal experiment to see how AI agents can be guided to understand requirements and produce reliable code. The results so far have been encouraging. The system isn’t live yet, but since introducing Gherkin and BDD into my workflow, I’ve noticed a significant improvement in context understanding and code quality.
The Philosophy Behind Verifiable Shortlinks
Aethralink isn’t about shortening URLs. It’s about rethinking the relationship between proof and convenience. In the modern web, speed has often replaced certainty. We click, share, and trust by habit. The idea of a verifiable shortlinkchallenges that habit. It suggests that trust should be a property of design, not an afterthought.
There’s something satisfying about the idea that even the smallest piece of digital infrastructure, a link, can carry integrity within itself. Aethralink does not depend on blind trust. It verifies what it claims.
This approach fits the larger philosophy behind my Weekend Lab projects: systems that behave as if they understand the moral weight of information. The more I work on orchestrating code through context-driven development, the more I realise that secure systems are not built through paranoia but through clarity and intent. Users deserve to know when something is authentic.
On Building in Public
One of the most rewarding parts of this process is building in public. The updates here are not marketing; they are notes from the collaborative markdown notes I’ve been developing with AI throughout this project, which also form the foundation of the admin and user manual documentation. Every improvement is an experiment, and every misstep is part of the documentation.
Even at this early stage, there hasn’t been much feedback yet. That’s expected. Right now the updates are more like open notes, a way of thinking in public rather than asking for reaction. I’m building the foundation first, the part no one sees but everyone will depend on later. When the demo arrives, that’s when the real feedback will matter.
Resilience and Memory
This section focuses on Aethralink’s persistence layer, which includes the database and audit logging that preserve configuration and decision history rather than any form of AI-driven contextual memory.
Software evolves quickly, and with every update it’s easy to lose track of how things came to be. I wanted Aethralink to resist that. Each credential records when it was created and by whom, while the database logs every change to its configuration. Over time this becomes a visible history of the system’s growth, a record that shows where decisions were made and why. It’s not just data storage; it’s context preservation. That continuity matters as much as the code itself.
What’s Next
There’s still plenty to finish: the verification API, the user interface, and the first public demo. Once those are in place, Aethralink will enter its first testing phase with external users.
The next steps also include adding validation of shortlinks against Web3 domains so that ownership and authenticity can be proven across decentralized identities. This will connect Aethralink directly to the broader Web3 ecosystem, ensuring links can be verified not just through cryptography but also through domain-level identity.
Future updates will explore how the verification API can integrate with browsers, CMS tools, and publishing systems. The idea is to let anyone issue a verifiable shortlink from within their own environment. That’s when the project becomes truly useful, when verification feels invisible, not imposed.
I’ll post the next full progress update on Friday, October 24, once the verification layer and initial interface are live. If all goes well, that post will include the first working demo and performance data. Until then, the work continues quietly: testing, refining, and preparing the system to prove itself in public.
Closing Reflection
Every project eventually becomes a mirror. Aethralink began as an experiment in Web3 verification, but it’s turning into something more personal. The deeper I go into the logic of proof, the more I see how much our systems reflect the values we embed in them.
Building verifiable links might seem like a small step, but if we can prove something as simple as a URL, we can rebuild credibility piece by piece. The goal isn’t to make the web perfect. It’s to make it accountable. That’s a start worth working for.
