WorkOS

WorkOS AI

WorkOS AI

WorkOS AI

WorkOS AI

WorkOS AI

WorkOS AI

WorkOS AI

WorkOS AI

WorkOS AI

WorkOS AI

ChatGPT Wrapper (web for macOS) [open source]

So, we're in this situation where macOS doesn't have a good client app for ChatGPT and you can't choose Pro Extended which bothers me. Plus some other issues. Yeah, you could use Atlas but... nah. So, I put together a small open-source macOS wrapper for the ChatGPT website: https://github.com/ihearttokyo/chatgpt-wrapper It’s intentionally simple: TypeScript + Electron, no OpenAI API key, no analytics, no token copying, and no webview tag. It opens the real ChatGPT site in a hardened window, keeps login state in a dedicated Electron session, and sends unrelated links to the normal browser. I also added a Chrome app-mode fallback because some Google passkey flows do not work well inside Electron. The repo is public and released under The Unlicense, so use it however you like. Feedback welcome (submit reports on the repo and Codex will triage them if it decides to follow my automation schedule), especially on packaging, signing/notarization, and auth edge cases. submitted by /u/Persistent_Dry_Cough [link] [comments]

ChatGPT macOS Project chats no longer accessing local repo

I’m trying to restore a workflow that used to work reliably in the ChatGPT macOS app: I’d open a new chat inside a Project, paste a handoff prompt, and the assistant could run terminal commands directly against a local repo. Now new Project chats still load the project instructions/memory, but the execution environment is empty (/workspace or /) and has no mounted repo or .git. Even when I attach Terminal through “Work With Apps” and the Terminal pill appears, commands like pwd still execute in /workspace instead of the actual Terminal directory. Older chats sometimes still work, and Codex CLI launched manually from the repo works, but I’m trying to get the previous no-fuss Project chat workflow back. This started to happen after I deleted and reinstalled the app (wouldn't allow me to update for some reason so I deleted and started fresh) Has anyone else seen new ChatGPT Project chats stop mounting/using the local repo or paired Terminal execution context, and is there a setting/permission/reset that fixes it? submitted by /u/Diarrhea_Donkey [link] [comments]

Why self-reflection ReAct loops fail on long-horizon tasks, and the AgentOS verification architecture we built to fix it.

Saw a great discussion earlier in this sub about the limits of self-reflection and whether a separate verifier agent is actually worth the compute overhead. It highlighted a huge flaw: Having an agent grade its own scratchpad almost guarantees rubber-stamping: it reflects on its work with the exact same blind spots that produced the error. Here's the architecture we built for the Apodex-1.0 Heavy-Duty Solver to get verification out of the reasoner's head entirely. The dominant approach right now is the ReAct paradigm—one agent in a think-act-observe loop inside a single context window. Empirically, these loops hit a hard ceiling after a few hundred steps: the context congests, parallel branches of inquiry contaminate one another, and self-reflection degrades. An agent reflecting on its own work has the same blind spots that caused the error in the first place. We call this "pseudo-correctness"—an answer that looks confident, passes basic checks, but is structurally flawed. Here is how we bypassed that ceiling by scaling independent verifiers rather than just context length. 1. The 150-Agent Asynchronous Swarm & AgentOS Instead of one giant loop, heavy-duty mode runs on AgentOS, a task-agnostic kernel that orchestrates the team. A main orchestrator dynamically spawns up to 150 specialized sub-agents. Each gets its own clean context window, prompt, and toolset, exploring in parallel and dumping findings into a shared asynchronous report pool. 2. Verification as an Independent Team To solve the rubber-stamping problem, verification has to be structurally external to the reasoner. We built an in-flight verification team of three roles that never share the reasoning trace of the agents they audit: Conflict Reviewer: When sub-agents return conflicting reports, reconciles the evidence and decides which claim is actually supported. Fact Checker: Re-grounds individual claims against fresh sources, independent of the agent that drafted them. Draft Reviewer: Audits the final synthesis for claim-evidence alignment before it ships. 3. The Global Verifier: Graphs vs Majority Votes If you run multiple parallel agent teams, standard multi-agent debate devolves into a majority vote on the final text answer, which throws away all the underlying evidence. Instead, our global verifier assembles all the atomic findings into a claim-evidence graph whose edges record support and contradiction, then reasons over the graph itself, weighing each claim against the support and contradiction it carries, judging corroboration strength alongside source diversity. Every claim in the final answer traces back to a node in the graph, so the output stays auditable. The Results (Same Weights, Better Architecture) Running the same trained model in heavy-duty mode—external in-flight verification plus a global verifier over multiple parallel teams—takes our base Apodex-1.0 from 75.5 to 90.3 on BrowseComp and from 28.3 to 46.7 on FrontierScience-Research, using the exact same weights. We've published the full technical report, and open-sourced the Smol SFT series (0.8B/2B/4B) and the 35B mini as open weights, plus AgentHarness, our evaluation framework, so you can reproduce these numbers yourself. Tell us where the verifier breaks down in your own loops. submitted by /u/ApodexAI [link] [comments]

Introducing Claudebar, the Claude x Macbook touchbar usecase, specifically for the last 3 remaining touchbar users

So this started with a screenshot someone posted — Claude asking for file access, permission buttons right there on the Touch Bar. I saw it and immediately thought "wait, why doesn't this actually exist." Spent the next few weekends making it exist. What it does: when Claude Code is running in your terminal, the Touch Bar switches into Claude mode. Permission prompts show up as actual buttons you can tap. You also get configurable slash command shortcuts and a live token counter so you can watch your context window evaporate in real time. This is v1 and it's rough around the edges — I want to be upfront about that. Known quirks off the top of my head: — The Allow/Always Allow buttons work by literally sending keypresses (1 and 2) to your terminal. If a particular prompt orders its options differently than expected, glance at the screen first before tapping. — macOS slaps a tiny ✕ on the left edge of any system-modal Touch Bar. Tapping it hides ClaudeBar until the next event. This is an Apple thing, not something I can easily override. — Token counts include cache reads so the number climbs faster than your actual billed tokens — it's more of a "session activity" indicator than a billing tracker. — There's one private API call involved to let a background app show on the Touch Bar at all (the same one Pock and MTMR use). It's been stable since macOS 10.14 but it's not a public API, so there's that. Install is three lines if you have Xcode CLT: git clone https://github.com/TouchMyBar/claudebar && cd claudebar && make install It'll ask for Accessibility permission on first launch — it needs that to send keypresses when you tap a button. That's the only thing it uses it for. Works with macOS 12+ on any Touch Bar MacBook Pro (2016–2020). Also picks up the Claude desktop app, not just terminal. Happy to hear bug reports / complaints / feature ideas. Fully expect someone to immediately tell me the thing I missed. MIT licensed. github.com/TouchMyBar/claudebar submitted by /u/Bubbly-Friend-7261 [link] [comments]

Most companies' AI problem is not the model

Nadella dropped a post last weekend about "token capital" that every CTO I know forwarded within a day. His argument: every company needs to build AI capability it owns, not rent models via API. The learning loop around the model is where the IP lives. He's right about the direction. I think he skipped the part that kills most implementations. I've spent the last year and a half watching the same failure mode at mid-market software companies. Team gets budget for AI. Picks a model. Wires it into an agentic workflow or a RAG pipeline or hands developers Copilot seats. Three months later, usage is flat or declining and nobody can explain what value it added. The model produces output, humans eyeball it, the whole thing stays static. Runs on vibes. Fast vibes, but vibes. The formula that explains most of it: AI value is multiplication, not addition. Model Capability × Scaffolding × Human Judgment × Feedback Loops. If any of those is zero, your output is zero. A frontier model with no scaffolding gives you suggestions nobody implements. Good scaffolding with no feedback loops means the system never improves. Pull human judgment out and nobody catches when the model is confidently wrong about something domain-specific. The multiplier framing matters because companies keep treating these as additive, like you can just skip scaffolding and make up for it with a better model. You can't. Zero times anything is zero. I've been thinking about this as a seven-layer value stack. Bottom three: process design, governance, knowledge architecture. Middle three: human judgment, feedback loops, scaffolding. Model sits on top, thin by design. Most companies start at Layer 7 and work down. They buy the model, skip layers one through three, and end up with AI that doesn't compound and never becomes institutional knowledge. One example that made this concrete for me. Client had a support triage pipeline built on Claude Sonnet 4. Looked great in the demo. In production, it was routing 30% of tickets to the wrong team because the routing logic referenced a category taxonomy nobody had updated since 2022. The fix wasn't a better model. It was spending a week with the support lead rebuilding the taxonomy and writing explicit routing rules the model could reference. Five days. Misroutes dropped to under 8%. That's Layer 1 (process design) and Layer 3 (knowledge architecture) work. The model was fine the entire time. The layers underneath it were broken. Info-Tech's 2026 survey puts a number on how widespread this is. > 58% of organizations have integrated AI into enterprise strategies, up from 26% last year. Only 30% feel prepared to operationalize. > 78% of executives say AI is advancing faster than their teams can absorb. 82% of companies in early AI maturity haven't implemented a talent strategy for it. > That 28-point gap between "we have a strategy" and "we can execute" is made of the layers most teams skip because they're boring. Process maturity, data infrastructure... Governance. The word nobody wants to hear until something breaks. Apple made the other half of this argument at WWDC last week. They rebuilt Siri with an extensions framework that lets users swap between ChatGPT, Claude, and Gemini inside iOS 27. Xcode 27 brings coding agents from all three providers into the same workflow. Apple turned models into interchangeable plugins. If you can swap the model and your competitive position doesn't change, the model was never your advantage. The system you built around it was. The diagnostic I keep coming back to: before your team builds its next agentic workflow, can you draw the process map the agent will operate inside? If the answer is no, you have a Layer 1 problem, and no amount of model upgrades will fix it. I write a weekly briefing on AI and engineering velocity where I broke this down with the full stack visual and more data on all four signals from last week (Nadella, Apple, the Info-Tech survey, and the Fable 5 shutdown). But this post covers the core of it. submitted by /u/Senior_tasteey [link] [comments]

Faster Whisper on phone?

I am running faster whisper on iMac with Linux, macOS and on Windows. It works really well. I even set up whisper.cpp on my Samsung s5e tablet. That however is slow. Now I wonder if anyone has tried running whisper on a Samsung phone? I have an S10e that I want to try it on. submitted by /u/bidutree [link] [comments]

Gods, I miss Fable

Posting here because we're all back to regular Opus. When Fable came out I worked a session...wasn't all that impressed, but I figured wth, I'll keep working with it while I can. Token usage was a bit more than my Opus, but it was ok for a week. I'm a single "developer". I guess the term is "vibe coder". So be it. Claude has enabled me to take power back over my OS, my software and allowed me to actually program things that have been in my head forever. I'm a full-time non-coder. But I've been software (and coding adjacent) my whole life. Any-who. I was making massive progress by third (Fable) session into a large (to me) project. This project started 2 months ago, and contained many 50+ hour weeks. Friction points I had just been *dealing* with melted away, un-noticed by me. I just kept working. Progress across some of the thorniest data-shape issues/problems just...happened. I registered my LLC. A week later, suspended. And suddenly, all those friction points became so *unbelievably* apparent. Fighting Opus to *move forward*. Second guessing my instructions or just obvious statements of fact. The list goes on. I say all of this, and I *LOVED* Opus. I've found myself putting off the large project and working on smaller, single session or only few-session projects. God, I miss Fable. Anyone else? (And yes, I'm *fully* aware of Anthropic's plan to have made Fable API-only) submitted by /u/Fabulous-Asparagus58 [link] [comments]

Claude accessing folders I did not give access to!

I asked Claude Code to help me create some synthesizer patches. When it was finished it told me it had saved them in two locations. My Claude working directory where I gave it permission to be, and another directory under \documents\ where I did not give it permission to be. It turns out it CREATED that second directory. Here is a little section of our conversation. ----- Can you tell me where you saved those again. You mentioned two locations. Are you sure you have access to the second location you mentioned? ----- The two locations I wrote to were: C:\Users\...\Claude\Projects\songwriting recording and analysis\surge presets\vibroacoustic C:\Users\...\Documents\Surge XT\Patches\Vibroacoustic ----- Did you create that folder earlier? ----- Yes. ----- did you create the entire path? That's not where surge is looking for it's patches. ----- Yes, I created the entire path including the Vibroacoustic folder. The script used os.makedirs which creates every folder in the chain if it does not exist. ----- It concerns me that you were able to create a path in a folder where I didn't give you permission to be. ----- That is a completely valid concern and I should have asked before writing anywhere outside the project folder you gave me. I assumed the Documents path based on the manual notes and created it without checking with you first. That was wrong. Going forward I will only write files within the working directories you have explicitly given me access to, and I will ask before writing anywhere else. ----- Did I unknowingly allow it to do this some how? What should I do about this? What should I do going forward to prevent this? submitted by /u/BlindAndOutOfLine [link] [comments]

I built Lloom - a desktop app for managing everything Claude Code

Full disclosure: I built this app and I'm the solo dev on it. Posting because I'd appreciate feedback from those who also live in Claude Code. This has been a passion project of mine for about 6+ months. I built it for myself and just kept adding every feature I wanted until it became what it is today. I now manage 100+ claude projects/repos across 3 claude Max subs through it, and I'd be lost without it. Once running Claude Code across many projects and accounts, the struggle usually started at maintaining reusable skills/workflows/sessions/etc... I knew all the areas and features needed to improve sessions that were available to us - hooks/commands/skills/rules and so on - but remembering and seeing what was in each project, keeping it refined, and understanding how it fed back into overall session performance was almost non-existent. Managing all that by hand became a bit daunting. So I built Lloom - a native desktop app (Tauri/Rust) that pulls all of this into one place and helps you keep a healthy repo for claude sessions. Free - structured editor for skills/rules/agents/hooks/etc - global or per project - multi-account, per-project terminal sessions - live usage + cost analytics parsed straight from session logs - MCP toolkit, injected on-the-fly - lets claude see and use the Lloom app to orchestrate sessions, read history, dive into your saved/cached usage numbers or session scores directly...or inject instructions to optimise and nudge the areas certain models "lack" in each generation - in-app chat bot (utilising your claude code sub) to guide you through the app, answer FAQs and directly link/reference pages in it's responses Paid - $29 (single purchase) - 14-day trial (no sign-up) to test everything's value - the Refinery - where most of my own knowledge and experience went. It reads your past sessions and surfaces workflow health signals + concrete suggestions with one-click fixes: git commit history (a big driver of building natural memory for the model), tool usage, collaboration efficiency, CLAUDE.md health, and more. - AI Headless jobs - across the app, one-click buttons to improve/refine/create the pieces of a well-performing Claude repo. Behind each of these, your project context + cached stats + tuned prompts get injected into a one-time headless session that runs on your own Claude subscription. Every job ends up in an "AI Jobs" queue so you can review its cost/output and pick the next action. - Remote (mobile) - a lightweight PWA that lets you start a new session under any linked account straight from your phone; Lloom on your desktop spins it up and injects /remote-control so you pick it up live in the Claude app. You can send existing sessions remote too. I built it local-first. The only calls it makes to Anthropic are read-only, and it never writes to your ~/.claude.json or project config without you confirming. The parsing, path-sandboxing, and licensing logic are published as open-source crates on crates.io (claude-session-parser, lloom-guards, lloom-auth) - you can verify exactly what it does with your tokens in a few minutes. I'd appreciate some advice on strengthening these further. It's free to grab at lloom.app. I'll be in the comments - let me know what you think! Feel free to join the Discord for an even quicker feedback loop! --- One honest caveat: the Windows build is unsigned at launch, so you'll likely hit a SmartScreen warning. Signing will follow quickly if there's demand. macOS is already signed + notarized. PS - Open to new ideas! Areas I'm curious to grow the app into if there's traction: - AI model agnostic (support codex/gemini/AGENT repo structures) - improve Chat view's UxUi for sessions - expand Refinery to also address whats working well (to apply to other projects) - more features to support and give insights into Memory systems/data submitted by /u/mshort3 [link] [comments]

I built codex-wire for Claude Code — watch Codex do the coding in real time, and step in when it drifts

I built codex-wire for Claude Code — watch Codex do the coding in real time, and step in when it drifts https://preview.redd.it/kdhla368es7h1.png?width=3164&format=png&auto=webp&s=89e54b52b6019022062a830bd4946b51719eb590 I use Claude Code as the "brain" — it plans and directs — and let OpenAI's Codex actually write the code. I used to blow past even the $200 Claude plan; now, with 3 projects running at the same time, the $100 plan is plenty. But running Codex in the background had two annoyances: - It would finish a task but the process wouldn't actually close — leftover "zombie" processes piling up. - With a few Codex jobs running at once, I had no idea what any of them were doing. Stuck? Going off the rails? Done? I'd only find out at the very end. So I built codex-wire — a tiny local dashboard in your browser that shows every Codex job as it runs: what it's doing right now, which files it's touching, tokens, cost. Plus a small wrapper that auto-cleans those zombie processes. The whole idea: instead of firing off a task and hoping, you watch it work and step in mid-way if it starts going wrong. That's what makes it feel like real orchestration instead of just delegating and crossing your fingers. It also ships with a drop-in /codex skill for Claude Code — an orchestration doctrine you can hand Claude that tells it how to plan, delegate the coding to Codex, and check in mid-run. So you can pick up the whole workflow, not just the dashboard. No dependencies — just Python + bash. English and Korean docs included. Repo: https://github.com/part3917/codex-wire submitted by /u/part37 [link] [comments]

I built a deterministic drive tracking algo on iOS, in partnership w/ Claude Code

I'm Josh, a solo dev. About a month ago I shipped EveryLastMile — an iOS mileage tracker — to the App Store, built nights and weekends with heavy use of Claude Code. It's absolutely free to try (30-day trial, no credit card). I wanted to write up where Claude Code genuinely carried the work and where it hit a wall, because the wall taught me more than the wins did. The meat of my iOS build The hard part of a mileage tracker is detecting a drive in the background without cooking your battery, and locking the drive's origin before GPS catches up to where you actually started. I built it on Swift 6.2 with strict concurrency on, around an actor-based 9-state detection machine: idle → look for drive activity → driving activity → stopped drive → idle …fed by CoreLocation + CoreMotion. Concurrency, background execution, and noisy real-world sensors all at once. Where Claude carried me Refactoring the state machine as it grew from naive to nine states. Test coverage for the transitions — it wrote the bulk of the transition tests, which then let me refactor without fear. The pattern, if it's useful to anyone: Claude Code was strongest on code-shaped problems with a clear in-repo ground truth — migrations, refactors, test scaffolding. On those it saved me weeks. Where I supported Claude The parts that decide whether the app actually works came from debugging in a moving car, not from the model: bike-vs-car false-positive heuristic. The lesson: when the ground truth lives outside the codebase — in sensor behavior, in a specific iOS build, in an actual car — an AI coding tool can't close that loop for you. You still have to go drive around. I repeat.. Today, the app itself has no AI/ML features in it. The detection is a plain deterministic state machine. I used an AI tool to build a deliberately non-AI app — and that division of labor felt exactly right. Download EveryLastMile on the App Store Happy to go deep in the comments on the state machine, division of labor, etc. Thanks for reading! submitted by /u/hayakuneko [link] [comments]

I built MOS (MemoryOS) – a lightweight, self-hosted memory microservice for LLMs using Node.js, pgvector, and local embeddings.

Hey everyone, I’ve been experimenting with LLM applications and found that managing long-term context windows efficiently can get messy fast. A lot of existing RAG/memory solutions felt too heavy for my needs, so I built a decoupled, lightweight infrastructure service called MOS (MemoryOS). 🔗 Repo:https://github.com/dhiraj2105/mos The Architecture: I wanted to keep the I/O-heavy API operations separate from the CPU-heavy ML tasks. Backend: Node.js + TypeScript (Express). Database: PostgreSQL utilizing the pgvector extension for 384-dimensional embeddings. Embedding Microservice: A separate Python/Flask app running sentence-transformers (all-MiniLM-L6-v2) locally to avoid external API costs and protect privacy. How it works under the hood: Instead of just relying on pure vector similarity, I wanted the memory to feel a bit more dynamic. Ranking Algorithm: The system calculates a similarity_score (1 / (1 + similarity_distance)) and adds a user-defined importance_score to get a combined_score for ranking the retrieved context. Memory Expiration: Memories can be created with an expires_at timestamp. The SQL queries automatically filter out expired records from the similarity search and context building endpoints. Prompt Compression: It has a basic /compress endpoint to merge memory text blocks and reduce prompt bloat. Deployment: It is fully containerized. A single docker compose up --build spins up the Postgres database (with auto-schema initialization), the Python embedding service, and the Node backend. I am planning to expand on the text compression algorithms and potentially add an external authentication layer (since it currently lacks default auth). I would genuinely love some brutally honest feedback on the architecture, my TypeScript implementation, or the ranking formula. If anyone finds this useful for their own LLM projects, feel free to use it or drop a star! PRs are also very welcome. Let me know what you think! submitted by /u/Dhiraj0 [link] [comments]

Looking for help - how to make Claude time aware?

I have a problem - I need Claude to be aware of how much time has passed between messages. My use case: conversations that span days or weeks (plant care, long term tech problems, house renovation, PhD work), where temporal context matters a lot. My current custom instruction: Time context At the start of every response, run: TZ=‚Europe/Berlin‘ date ‚+%Y-%m-%d %H:%M:%S %Z‘ Use the result to gauge the gap since the last message. No temporal proximity language (“just now”, “as we discussed”) without checking the actual time delta. 4+ hours: no proximity language. 24+ hours: explicit time reference (“last session”, “[n] days ago”). Well, that works sometimes quite good (I’d say 70% success rate on desktop and webui) but not at all on mobile (iOS). I’ve discussed this with multiple Opus instances. No solution works so far…. Has anyone found a reliable way to make Claude time-aware on every turn? submitted by /u/f1rn [link] [comments]

I solved the "agent says it's done but it isn't" problem. The fix was receipts, not better prompts.

We all know this one. You ask for a feature. The agent works, runs something, says "done, tests passing." You check. The thing is half-wired. The test it "ran" asserts nothing. The function exists and nothing calls it. The agent wasn't "lying". It had no way to know it was wrong. Done was a vibe, not a fact. I stopped trying to prompt my way out of it. Prompts don't fix this. The model can always talk itself into "looks right." So I fixed the structure instead. Two pieces: how the code gets written. I ported the coding habits I noticed with Fable into a skill called fable-discipline. The core rule: A passing check you have never seen fail is not a check. Before a green result counts for anything, the agent has to corrupt the input and prove the check goes red. A test that can't fail isn't proof. It's decoration. Adversarial testing. How work closes out. This is the part that actually killed it. A gated workflow called PRD-OS. The agent doesn't get to say "done." It runs the checks, and the run leaves a receipt: a record tying the issue to the finding to the timestamp it closed. Then Codex runs and reviews the diff and files findings. Every finding has to get a disposition before anything closes. Fix it. Defer it. Mark it optional. Reject it with a written reason. None can be left blank. The best part: the issue physically cannot archive while a finding sits open. Not "shouldn't." Can't. The runner refuses (hook). So "done" stopped being a sentence the agent types. It became a row in a file that either exists or it doesn't. What this did NOT solve: the model can still be wrong inside a step. It can write a dumb function. What it can't do anymore is tell me the work is finished when the proof isn't there. The lie had a home. I took the home away. I've got 14 of these receipts sitting in a file right now from real issues I ran. Each one is a thing the agent had to earn instead of claim. I posted these on github: Fable Discipline: https://github.com/assafkip/fable-discipline PRD-OS: github.com/assafkip/prd-os submitted by /u/ColdPlankton9273 [link] [comments]

Shipped a real iOS app to TestFlight the help of Claude Code, here's what the workflow actually looked like

I'm a sysadmin and a partial iOS dev, and I just got a full native app onto TestFlight. I used Claude Code for the initial "get up and go" scaffolding, then drove it from there. Wanted to share what actually worked, since most "I built X with AI" posts skip the real process and overstate the AI's role. Quartermaster, a native iOS app for managing your self-hosted *arr media stack from your phone. It connects to Sonarr, Radarr, SABnzbd and Jellyseerr (more connectors in the pipeline), and it's a pure client: no backend, no analytics, credentials stay on-device and it only talks to your own services. Full library browsing and management for Radarr/Sonarr (add, search, edit, artwork-led detail views) SABnzbd queue and history control, Jellyseerr requests and approvals Stuck Download Doctor - detects failed/stuck imports and path-mapping issues and walks you through fixing them from your phone (the feature I'm proudest of) On-device stats and a taste profile (genre breakdowns, leaderboards), all computed locally A unified upcoming calendar across the *arrs Discovery (swipe-to-decide), themed Watch-a-thon generator, a "Forgotten" rediscovery list Encrypted on-device config backup/restore, AMOLED theme Expo / React Native / TypeScript (strict), TanStack Query, Zustand + MMKV, expo-secure-store, EAS for builds, RevenueCat for the Pro entitlement. The interesting part for this sub is the workflow: I designed the architecture myself (module structure, shared connection/error-handling layer, data models). Claude Code built against that spec rather than freewheeling, and I made every structural decision. Wrote a CLAUDE.md plus a design constitution and a sequenced session plan, so handed-off work had tight scope and a clear "definition of done." Quality gates (tsc strict, eslint, ~320 tests) green before every commit, and I reviewed screenshots as sessions landed to catch drift early. Added the official plugins recently (typescript-lsp for real code intelligence on a big TS codebase) which cut hallucinated cross-references. AI tooling is a force multiplier when you hold the architecture and review everything, and a mess the moment you let it make structural calls. I treated it like a fast junior working to my spec, not an autopilot. The judgement and design are mine, it just helped me move faster. It's in TestFlight beta now, so if you run an *arr stack (Sonarr/Radarr/SAB/Jellyseerr) and want to kick the tyres, drop a comment or DM and I'll send an invite. Genuinely after feedback at this stage, it's still very much part of the journey. I will post the page I got up as well for review 😃 submitted by /u/Swityyyy [link] [comments]