• 

  If the admin somehow gets disconnected from the apps mainstream it'll be flagged so the admin knows they aren't viewing a live dashboard.

ShadeFast: Trust Without Identity

Inspiration

Most social platforms depend on identity to function: who you are, your history, your reputation, your behavior over time. That dependency is also how they justify collecting as much data as they do.

I wanted to know if that dependency was actually necessary, or just the default nobody had bothered to question. ShadeFast started as an attempt to answer that: build a real social platform, communities, messaging, media, moderation, all of it, without persistent identity as the foundation.

The obvious problem: remove identity and you remove most of what moderation systems normally rely on. That's the constraint this project is actually about.

What I Built

ShadeFast is a privacy-first anonymous social platform (iOS, Android, web) with communities, private messaging, ephemeral rooms, media, and moderation, and none of it requiring persistent identity.

For this project, I built Trust Reasoner, a privacy-preserving moderation reasoning system architecturally designed for GPT-5.6 and integrated into ShadeFast's moderation workflow and really upgraded my existing moderation dashboard.

The system is complete at the application and infrastructure level, the reasoning contract, privacy constraints, evidence handling, structured output validation, authorization, persistence, immutability, fail closed behavior, and admin dashboard integration are all implemented and tested properly. The live model provider connection is not enabled in the submitted build, so the demo focuses on the completed moderation architecture and its integration rather than a live GPT-5.6 inference call I could not cover the demo in my video but captured other implications I made in this build week.

It doesn't score users. It reasons about a single reported message using only the immediate thread context, the community's stated rules, and bounded anonymous session signals, nothing about who posted it or what they've done before. The output is structured, cited evidence, an assessment, and an explicit confidence level. If the context isn't enough to reach a conclusion, it says so instead of guessing. It never takes action itself. A human moderator must decide.

Building It

Stack: Flutter, Supabase, PostgreSQL, Supabase Edge Functions, GPT-5.6, and Codex.

I used Codex as an actual engineering collaborator, not autocomplete, repository analysis before writing code, an architecture decision record, adversarial security testing, a hardening pass, and a refactor, in that order, each one reviewed before moving to the next. At one point Codex stopped mid-implementation because a set of moderator controls I'd specified had no defined behavior. Rather than guess, it flagged the ambiguity and asked me to define it. I did, and only then did implementation continue. That's the moment that best represents how this was actually built.

Challenges

The hard part wasn't designing a model call. It was defining what the reasoning system is not allowed to do, no identity inference, no inventing evidence, no automatic enforcement, and no false confidence. Those were not afterthoughts, they're the actual design.

The other hard part was making moderation decisions real instead of cosmetic. A dashboard that shows reports but doesn't affect the live app is a demo, not a product. So every action, removing content, issuing a warning, suspending a community, had to propagate through to actual enforcement at the data layer, and I verified that propagation end to end rather than assuming it.

Account continuity across devices without reintroducing persistent identity is the next problem I'm working on. I'm looking at and currently researching decentralised solutions but I don't have a very clean answer yet.

What I Learned

Privacy isn't a missing feature. It's a design constraint that removes your easiest fallback, you can't lean on identity or history when something's ambiguous, so you have to actually think through trust, authorization, and accountability properly instead of skipping to "check who they are."

That's harder to build. It's also the more interesting problem.

Built With

• cloudflare
• codex
• css
• dart
• deno(edge-functions)
• firebase
• flutter
• gpt-5.6
• javascript
• kotlin
• pages
• postgresql
• react
• sql
• supabase
• swift
• typescript