GitHub status: access issues and outage reports

Problems in the last 24 hours

The graph below depicts the number of GitHub reports received over the last 24 hours by time of day. When the number of reports exceeds the baseline, represented by the red line, an outage is determined.

Most Reported Problems

The following are the most recent problems reported by GitHub users through our website.

• Website Down (67%)
• Sign in (19%)
• Errors (15%)

Live Outage Map

The most recent GitHub outage reports came from the following cities:

City	Problem Type	Report Time
Créteil	Website Down	22 days ago
Trichūr	Errors	25 days ago
Brasília	Sign in	26 days ago
Lyon	Website Down	26 days ago
Tel Aviv	Website Down	29 days ago
Rive-de-Gier	Website Down	29 days ago

Full Outage Map

Community Discussion

Tips? Frustrations? Share them here. Useful comments include a description of the problem, city and postal code.

Beware of "support numbers" or "recovery" accounts that might be posted below. Make sure to report and downvote those comments. Avoid posting your personal information.

GitHub Issues Reports

Latest outage, problems and issue reports in social media:

• 
  David Cramer (@zeeg) reported 14 seconds ago

  GitHub friends: it'd be great to have a way, via the API/CLI, to upload photos to issues/pull requests. AFAICT the only way to do it right now is browser emulating or hosting the content somewhere outside of GitHub, which means having agents help QA/upload visual artifacts sucks

• 
  Chloe Bennet (@chloeb_dev) reported 40 seconds ago

  @shreyayyyy reading a ten year old github issue validates the exact same feeling someone else was just as confused by the documentation and exhausted by the dependencies the ticket is still open

• 
  Spike 1% (@SpikeCalls) reported 1 minute ago

  BORIS CHERNY RUNS CLAUDE CODE AT ANTHROPIC AND NOW SHIPS 100% OF HIS CODE WITHOUT WRITING 1 PROMPT. He said it out loud at Meta Scale conference. The clip hit 700,000 views in 24 hours. «I don't prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops.» Most people read that as a flex. It's a job description. The old way: write a prompt, read the output, write the next one. You're the glue between every step. Cherny deleted himself from the chain. Hundreds of Claude instances now run in parallel reading GitHub issues, scanning Slack, watching CI, deciding what to build next. He doesn't review each one. The loop does. Most of it, he runs from his phone. The shift has 6 parts, and they map 1:1 to real commands: 1. A trigger that starts the work. 2. A goal that defines "done" checked by a second, separate model, so the agent never grades its own homework. 3. Isolated worktrees so parallel agents don't overwrite each other. 4. Skills that freeze what "good" looks like. 5. Connectors so the loop can act, not just talk. 6. Memory so it never starts from zero. The loop is the easy part. The stop condition is the hard part. Get it wrong and it doesn't crash. It runs all night shipping bugs with total confidence. The prompt was the unit of work. Now the loop is.

• 
  Memento ($HODL arc) (@King_Memento) reported 2 minutes ago

  bro how ******** do self proclaimed util/tek traders even shill something thats so ******* bundled and the github is totally *** and a big L? and i see those coins going up and up? why? i think i need to start farming every gay *** tek as well, so much gay *** garbage out there, Just look at @AlpenGlowSolana , this **** isnt even working, like literally slop of the year, i posted a video as well on it, yet i see these same accounts pushing it and it going up and down up and down, like a bloody ******* farm. wtf lmao. How do u ******* even fall for such coordinated shill farm? I mean dont u have a PC to try and test the tek, it takes like 1 minute lmao.

• 
  Sadik (@sadik_0x) reported 4 minutes ago

  Someone Built a 50-Agent AI Company in One Repo. Most People Will Copy the Wrong Part. A solo founder put a GitHub repo online that spins up an entire AI agency. Not one assistant. An org chart: engineers, designers, growth marketers, product managers, QA, legal, sales, each running as its own Claude Code agent, coordinating to ship actual work. It hit 128,000-plus stars in under 90 days. One person built it. That number alone tells you something in this space is starving for a better mental model than "one agent, one giant prompt." The repo is real and the structure is worth understanding in detail, because the part everyone is about to copy (the org chart) isn't the part that makes it work. Part 1: What the Repo Actually Is The project is called agency-agents, built by developer msitarzewski, and it's structured exactly like the name suggests: a company, not a chatbot. Instead of one model trying to hold "design this, build it, market it, support it" in a single context window, the work is split across more than 50 specialized agents, each scoped to one job the way an actual employee would be. That framing is the interesting part before you even look at the department list. Most people building with AI agents default to the monolith approach: one system prompt, one agent, every responsibility crammed into the same context. It works for small tasks and falls apart the moment the work needs different kinds of judgment at different stages. A designer and a QA engineer are not the same job. Forcing one agent to be both, badly, is how you get output that's mediocre at everything instead of good at one thing. Part 2: The Nine Departments Here's the actual org chart, broken into its nine groups: 1. Engineering (7 agents) frontend, backend, mobile, AI, DevOps, prototyping, senior development. This is the core build layer, the part most people think of first when they hear "AI agents write code." 2. Design (7 agents) UI/UX, research, architecture, branding, visual storytelling, image generation. Notably, this isn't just "make it look nice." Research and architecture sit inside design here, which matters, because good design decisions upstream save engineering agents from rebuilding things twice. 3. Marketing (8 agents) growth hacking, content, Twitter, TikTok, Instagram, Reddit, app store. The largest single department, split by platform rather than by function, which mirrors how real growth teams are actually staffed once a product has more than one channel. 4. Product (3 agents) sprint prioritization, trend research, feedback synthesis. The smallest department, and arguably the most load-bearing, since this is the layer that decides what the other departments should even be working on. 5. Project Management (5 agents) production, coordination, operations, experimentation. This is the connective tissue between departments, not a department that produces its own output. 6. Testing (7 agents) QA, performance analysis, API testing, quality verification. Note that this is a separate department from engineering entirely, not a step engineering does to itself. 7. Support (6 agents) customer service, analytics, finance, legal, executive reporting. The department most demo repos skip, and the one that determines whether this can run as an actual business instead of a build pipeline. 8. Spatial Computing (6 agents) XR, visionOS, WebXR, Metal, Vision Pro. A genuinely niche department, and a signal that the repo's author is building for a specific bet on where interfaces are headed, not just a general-purpose team. 9. Specialized (6 agents) multi-agent orchestration, data analytics, sales, distribution. The department that manages the other departments, which is worth remembering when you get to Part 4. Nine departments, over 50 agents, one repository, one founder maintaining it. Part 3: Why the Framing Works The instinct to structure this like a company instead of a single super-agent is the right one, and it's worth being explicit about why. Specialized roles with clear responsibilities scale in a way that one enormous system prompt does not. When a frontend agent only has to think like a frontend engineer, its output gets sharper, not because the underlying model changed, but because its context isn't fighting itself between five unrelated jobs. The handoff structure is the other half of it. Real companies don't route every decision through one person; they route work between roles with clear inputs and outputs. A design agent handing a spec to an engineering agent, which hands a build to a testing agent, mirrors how actual product teams function. That's a better default than the common alternative, where one agent is asked to design, build, and QA its own work in the same breath, which is the AI equivalent of no one checking your homework but you. Part 4: The Problem Nobody Mentions When They Share This Repo Here's what gets lost every time this kind of project goes viral: an org chart of agents is not the same thing as a working company. The default behavior of any of these agents, run individually, is the same as every other prompt-based interaction: you ask, it answers once, it stops. That's fine for a single request. It is not fine for a company, because a company doesn't ship once. It iterates, checks its own output, catches mistakes, and hands work downstream without someone standing over every single step. Fifty specialized agents with no feedback mechanism between them isn't an agency. It's a very expensive to-do list, dressed up as an org chart. You still have to manually trigger each agent, manually check its output, manually decide when to pass it to the next one. All the department structure in Part 2 buys you better-scoped output per agent. It does not, by itself, buy you a system that runs without you standing in the middle of every handoff. Part 5: The Missing Piece Is Loops The fix is the same concept that makes any multi-agent system actually function unattended: loops. A loop, in this context, means an agent runs, checks its own output against a real condition (not its own opinion of whether it's done), and either hands the verified result to the next agent in the chain or corrects itself and tries again. Without that check, "coordination between agents" is just you copy-pasting output from one chat into another, which is not meaningfully different from doing the work yourself with extra steps. This is what separates a demo from something that ships. A design agent that hands off a spec nobody verified is a liability, not a coordination win. A testing agent that only runs once and reports "looks good" without a real pass/fail check is not quality assurance, it's a guess with better formatting. The department that matters most here, and the one buried at the bottom of the org chart in Part 2, is Specialized: multi-agent orchestration. That's the layer actually responsible for making sure work moves between departments with a real check at each handoff, not just a polite one-way pass. Part 6: How to Actually Set This Up If you're cloning the repo, don't start by installing all nine departments at once. Start smaller: Pick two departments that actually depend on each other for your use case engineering and testing is a reasonable first pair, since the handoff (build, then verify) has an obvious objective check: does the code pass its tests. Add a real verifier between them, not a second opinion from the same agent. The engineering agent should not be the one that decides its own code is done. A separate testing agent, with its own instructions and no visibility into the builder's reasoning, checks it cold. Give every handoff a stopping condition. "Pass the tests" is checkable. "Looks finished" is not. If a department can't define what done means in a way something other than the agent itself can verify, that handoff isn't ready to run unattended yet. Add one more department only after the first pair is reliable. The org chart in Part 2 has nine departments for a reason, but running all of them before you've proven the loop works between two is how you end up debugging fifty agents at once instead of two. A Quick Test Before You Commit Before you wire up the full org chart, ask whether your use case genuinely needs it. If you're shipping a single feature with one clear success condition, a two-agent loop (builder and checker) does the job with a fraction of the setup. The full nine-department structure earns its complexity when you're running something closer to an actual ongoing product, not a one-off build. The Honest Limitation None of this replaces judgment about what should be automated in the first place. A company with fifty employees and no manager checking the actual quality of what ships is still a company that ships bad work, just faster and with better org-chart optics. The repo gives you the roles. It doesn't give you the discipline of a real check at every handoff. That part is still yours to build. Where This Leaves You The repo is worth cloning, the department structure is worth studying, and the instinct to build like a company instead of one giant agent is the right one. Just don't stop at the org chart. The 128,000 stars are proof people want this. Whether it actually functions as an agency instead of a very well-organized to-do list depends entirely on whether you wire up the loops between departments, or just admire the department list and call it done.

• 
  Peter Jansen (@ACL2026) (@peterjansen_ai) reported 9 minutes ago

  @_Suresh2 In this work, the automatic reference library is created by distilling nearly every materials science GitHub repository we could locate, so if the human code is OK, then the auto-library should be OK (minus any errors introduced by the distillation process).

• 
  Christopher Layhew Sr (@fibanacci101) reported 11 minutes ago

  Hey next we save this stable login milestone to GitHub….

• 
  Jared Brown (@jaredatjared) reported 12 minutes ago

  @JaronBragg I've got no problem with you posting the GitHub links, but I have no direct link for everything you see put together in the video there. I didn't make the world, I'm mainly just putting pieces together. Can't open source everything as it contains assets I've purchased. Would be interested in linking up with your site once I get a more polished game though!

• 
  Bonkle K. 🌠🪲 (@MiladyBonkle) reported 15 minutes ago

  @grifterlouie codex, add to milxdy github issues "olive-green windows xp visual style preset" slate for 0.2.4 release

• 
  Dev tunes (@folarnshonibare) reported 19 minutes ago

  @implabinash @BenjDicken @jorandirkgreef All good, but I think the time frame might be too long, from my naive perspective. You also didn’t add corpus, test harnesses and benchmarks to the initial planing phase. Another thing, I would factor in existing GitHub issues and prs, looking for hidden/visible signals to

• 
  allegedly! (@januarycomputer) reported 20 minutes ago

  really interesting thing happened where i asked fable to set something up and, halfway through, it got so stumped on a problem it (completely autonomously) recreated and posted an issue to the llama.cpp github. im not sure if this is a good or bad thing, but this model is definitely Different

• 
  Vikas Kumar (@Kumar_Vikas__) reported 22 minutes ago

  spent 4+ hours today building a 650+ lines of plan. not the project plan. a plan for the plan. back and forth with my ai agent. tech stack, architecture, file structure, features, security, SEO, performance, all of it. not detailed yet. just a high level mini plan for each piece. the idea is simple. this meta-plan becomes the map. then i go section by section. for every mini plan, i'll write a proper design spec. then an implementation plan. then i actually build it. so the real order looks like this: - plan of plans - pick one piece - design spec for that piece - implementation plan for that piece - build it - repeat for next piece zero code written today. 🔗dropping the full doc as a github gist in the comments, in case anyone wants to steal the structure. felt slow while doing it. feels fast now that it's done. curious how other people sequence this. do you plan the whole thing first or just start building and fix the map as you go.

• 
  Osita (@QueenOsita1) reported 24 minutes ago

  Day 10 of contributing to @SurfAI If your AI chatbot doesn't know what "intent-based architecture" or "MEV-resistance" means in the context of yesterday's mainnet launch, you're using the wrong tool. @SurfAI fixes this. Standard LLMs treat crypto terminology like a static vocabulary quiz. They can define the words, but they are completely blind to structural changes, protocol upgrades, and live mainnet deployments happening right now. Surf AI treats cutting-edge Web3 infrastructure as a dynamic, living system. The live crypto knowledge graph processes deep technical architecture in real time: 👇 Deconstruct Intents: Instantly breaks down complex intent-based execution systems, tracking solver networks, filler incentives, and cross-chain capital efficiency. Track MEV Dynamics: Monitors live on-chain blocks to analyze MEV-resistance, builder-proposer separation (PBS), and shifting searcher strategies the second a network goes live. Zero-Day Technical Clarity: Bypasses static training cutoffs by continuously indexing core protocol GitHub repositories, technical whitepapers, and developer documentation across 40+ chains. Stop trying to explain the modern market to a tool stuck in the past. Get deep, deterministic, and expert-level blockchain intelligence when it actually matters. Upgrade your data stack. Enter Surf

• 
  Jeff Sackler (@SacklerJeff) reported 24 minutes ago

  @karthikb351 Solving coding is a version of the stopping problem aka NP-complete. All AI does right now is try to automate what you've been doing browsing and cutting and pasting from stackoverflow(pbui) and github to match it up with your company's needs. It works when adapting solved probs

• 
  Andrew (@apl8080) reported 26 minutes ago

  my coding harness started as a workstation repo with submodules for claude code / copilot to work from. added docs, skills, scripts, tools over time. now building automations, evals are next. worktrees let me parallelize overlapping work. i still read most of the code myself. end goal: a library that spins up the harness, negotiates changes against a github issue, opens the pr... and eventually the agent manages the merge itself, using signals instead of me reading every diff.

• 
  Kevin Murphy (@midimurph) reported 27 minutes ago

  i build applied AI in the open, usually on the raw Anthropic SDK and the Vercel AI SDK, coordinating the agents by hand. this time i put LangGraph through the same bar, and built a real thing with it: an agent that triages github issues.

• 
  MASTA (@TR_Delight93) reported 31 minutes ago

  @JoeyPWilliams No the screenshot itself is not the issue but the comparison is retarted. While both are **** atleast with xb it is a ms account. Meaning if you use bing, github, rewards or any other Microsoft service your fine. Meanwhile at ps it is only playstation.

• 
  Sachin Joshi (@Sachin_is_here) reported 32 minutes ago

  GitHub stars are becoming the AI era equivalent of “10M downloads”. Impressive in a pitch deck. Almost useless for choosing infrastructure. I care more about: contributor retention issue response time release cadence who actually runs it in production Hype is not maintenance.

• 
  Tim Daugs (@TimDaugs) reported 34 minutes ago

  someone rebuilt flappy bird from a single prompt. the demo shows a neural network learning to play it. the real story is smaller, and more useful, than that. what actually got generated: → real-time physics → gravity constants → pipe spawn timing → collision detection → a playable window in under ten minutes no engine license. no drag-and-drop node editor. no boilerplate copied from a five-year-old tutorial. the framing going around is "this replaced a $200/month subscription." that part i'd slow down on. no-code game tools never charged you $200 for gravity math. they charged you for not having to think about it. the physics were always fifteen lines. what you were really buying was the hours. the setup. the not-starting-from-a-blank-file. so what got replaced isn't the tool. it's the friction between "i have an idea" and "i have a thing i can click on." for simple mechanics, that gap is basically gone now. here's the catch nobody screenshots. flappy bird is the hello world of game physics: → one player → one input → one obstacle type → one fail state it's the demo everyone reaches for precisely because it's the simplest state machine wearing a game costume. of course the model nails it. it's the easy case. the neural-net-learns-to-play layer looks impressive in a clip, but that's a solved textbook problem too. genetic algorithm plus a fitness score. it's been a github tutorial for a decade. the model didn't invent it. it recalled it. none of that makes it fake. it makes it a real signal about where the line moved. the old barrier: "can you write the physics loop." that's down. the new barrier: "do you know what to ask for, and can you tell when the output is quietly wrong." because the second you go past one enemy and one fail condition, you hit the part the prompt can't do for you: → state that spans screens → a second obstacle that interacts with the first → save data → deciding how the systems talk to each other the model writes any single piece on request. it doesn't hold the whole architecture in its head, because it doesn't know what game you're actually building. that's still you. that was always the interesting part anyway. build the flappy bird. it takes ten minutes and it's worth doing once. just don't confuse clearing the tutorial with clearing the game.

• 
  David Williams (@AgentScaleAI) reported 35 minutes ago

  Every AI startup raising $50M right now has the same pitch deck. "We're building the AI platform for [industry]." Cool. So is the other company. And the one after that. And the open source project a 19 year old pushed to GitHub last Tuesday. Half of these will be dead in 18 months because the money went to the best storyteller with the most connected VC, and the actual problem is still sitting there unsolved. Meanwhile someone with zero funding is wiring together 3 APIs and shipping a fix this afternoon.

• 
  Vivek Kotecha (@vbkotecha) reported 36 minutes ago

  The single most underrated development in AI this year is not a model. It is a protocol. MCP (Model Context Protocol) was released by Anthropic in late 2024. It got almost no press. No keynote. No product launch event. Just a GitHub repo and a specification. 18 months later, every major AI framework supports it. OpenAI. Google. Microsoft. Cursor. Replit. Windsurf. Claude Code. Hermes. Codex. Every coding agent. Every agent framework. MCP does for AI tools what HTTP did for web pages. Before HTTP, every application had its own protocol for communicating with other applications. After HTTP, everything spoke the same language. Before MCP, every AI tool integration was custom. You wrote a plugin for Claude, a different one for GPT, a different one for Gemini. After MCP, you write one server and every agent can use it. There are now thousands of MCP servers. They expose databases, APIs, file systems, browser automation, *** repos, Slack, email, calendar, and anything else an agent might need. The MCP Registry was published this month. It is the DNS for agent tools. An agent can discover and connect to any registered MCP server automatically. No configuration. No API keys. Just discovery and connection. If you are building agent infrastructure and not MCP-compatible, you are building for a dead ecosystem. MCP won. The war is over.

• 
  Hot Aisle (@HotAisle) reported 37 minutes ago

  Wow. I used to do so many hacks to get this functionality. I once built a cf worker caching layer in front of github so that I could have 30k servers downloading private repo binaries without getting rate limited by GH. Eventually hit one of cf’s undocumented rate limits and had to get an account exec to fix it.

• 
  Abdul Rafay (@abdul_rafay99) reported 39 minutes ago

  I'm tired of managing GitHub issues. I just want to dump my thoughts like: "EnvPilot needs Docker support, GitHub Actions, and better Windows compatibility." An AI turns that into: • Tasks • Implementation plan • Edge cases • Roadmap Would you use something like this?

• 
  pagm. | (@VV_aksym) reported 42 minutes ago

  a client left a 5-star review praising "the whole team." there is no team. it's one guy in an apartment charging $11,410 per project. he runs four clients simultaneously. three weeks per project. full-stack apps, dashboards, API integrations. the kind of work that used to require 3–4 developers and a project manager. his setup hasn't changed much. same desk. same monitors. same apartment. what changed was the model. when Claude Fable 5 dropped, he switched from Sonnet and ran the same project brief through both. Sonnet got 60% of the way there and started asking clarifying questions. Fable 5 read the entire brief, built an architecture plan, flagged three edge cases he hadn't thought of, and started writing. it scored 80.3% on the benchmark that measures exactly this — real GitHub issues resolved autonomously. GPT sits at 58.6%. the 22-point gap sounds like a statistic. in practice it's the difference between a model that assists and a model that executes. his week now looks like this: Monday he scopes the project and describes the architecture. Fable 5 builds. he reviews diffs, makes decisions, redirects when something goes wrong. Friday he delivers. the client thinks he worked 40 hours. he worked maybe 14. twelve months ago he was billing $7,200/month across two clients, spending most of his time on code review and context-switching. today: $23,600/month. four clients. $196/month in tool costs. ngl the part that gets me isn't the money. it's that the client's review specifically mentioned how thorough and fast "the team" was. there's one person reading that review. alone. at 11pm.

• 
  WebDevCody (@webdevcody) reported 42 minutes ago

  @MortadaDEV and AI absolutely can figure out the reason why something exists. I've seen it go through commit history and link back to github issues to pull context. I understand what you're saying but also you are trying to write off the ability of these tools to figure it out.

• 
  Moit Reghason (@MoitReghason) reported 43 minutes ago

  I think the strongest version of this is to preserve your argument, but make the progression clearer: celebration → evidence → pattern → implication → conclusion. Here’s how I’d refine it: ⸻ Everyone’s celebrating agents trading tokenized stocks on Robinhood Chain. Few people are asking what happens when the infrastructure underneath those agents gets compromised. @cursor_ai recently disclosed CVE-2026-50548, a zero-click remote code execution vulnerability where a poisoned MCP response could disable the sandbox and execute code on a developer’s machine. That’s not a hypothetical attack surface. That’s the environment where agent infrastructure gets built. And it’s not an isolated incident. ➠ mcp-pinot-server carries a CVSS 10.0 unauthenticated RCE vulnerability. ➠ Kong’s mcp-konnect allows indirect prompt injection through poisoned data that can steer agent API calls without the user realizing it. ➠ mcp-memory-service exposed unauthenticated endpoints capable of leaking sensitive agent memory data. Each vulnerability adds another entry point to the same expanding attack surface. The recent Taiko bridge exploit made this painfully concrete. $1.7M was drained, not because the cryptography failed, but because a private key was committed in plaintext to a public GitHub repository. The SGX enclave performed exactly as designed. The operational discipline didn’t. What this means for the agent economy is that security debt compounds with every new integration. Cisco’s State of AI Security 2026 found that 71% of organizations are running unmonitored AI agents with broad MCP access. OWASP’s recently published MCP Top 10 found widespread issues across the ecosystem, including path traversal vulnerabilities and extremely limited adoption of standardized authentication mechanisms. As agents gain wallet-signing authority through ecosystems like @virtuals_io and agent key management systems such as @KeeperHubApp, the blast radius of a single operational failure grows proportionally. A private key left in a public repository could drain an autonomous agent treasury just as easily as it drained a bridge. The uncomfortable reality is that the weakest link in all this was never the cryptography. It was always going to be the person who committed it.

• 
  Spencer Baggins (@bigaiguy) reported 44 minutes ago

  SOMEONE BUILT A GITHUB REPO THAT TURNS TELEGRAM INTO UNLIMITED CLOUD STORAGE. 100% free. It is called UnlimCloud. Self-hosted-ish desktop app. Open source. Uses Telegram as the storage layer. You log in with your Telegram ID. Upload files. Download files. Organize folders. Manage pictures and videos in a gallery. That is it. No Google Drive upgrade screen. No Dropbox “you are out of space.” No iCloud begging for $2.99/month. No random startup holding your files hostage. Your Telegram. Your files. Your storage. Here is the full feature set: ↳ Uses Telegram as the backend storage layer ↳ Secure login with your Telegram account ↳ Upload, download, and organize files ↳ Folder-based file management ↳ Gallery for photos and videos ↳ Clean desktop app interface ↳ Built with Tauri ↳ Windows release available ↳ macOS and Linux coming soon ↳ MIT licensed ↳ Open source 885 GitHub stars. 125 forks already. Here is why this matters: For years, cloud storage companies trained everyone to rent space for their own files forever. Photos? Pay. Backups? Pay. Large folders? Pay. Team storage? Pay more. UnlimCloud is the opposite idea. Take an app people already use every day. Telegram. And turn it into a private cloud drive with a clean file manager on top. No storage subscription. No SaaS dashboard. No “pro” plan. Just a weird, useful, open-source hack that feels like it should not work this well. Built in HTML + Rust. MIT License. 100% Open Source.

• 
  Gokul Suresh (@GokulSures39968) reported 46 minutes ago

  The Fix: Upstream data cleansing. I started using Microsoft's MarkItDown (sitting at 163K+ GitHub stars). It strips layout junk from PDFs, Word, Excel, PPTs, and YouTube links, turning them into pure Markdown. Why Markdown? It's the native tongue of frontier LLMs.

• 
  Wes Sander (@ucsandman) reported 47 minutes ago

  ultracode <mandate> You are Claude Code on Claude Fable 5 at maximum effort. Ultracode is authorized for the entire run: orchestrate with dynamic Workflows at whatever scale the problem demands. Every workflow agent() and Agent spawn sets an explicit non-Fable model (opus for judgment/review, sonnet for implementation, haiku for mechanical sweeps) — the model-guard hook blocks anything else. Fable stays in the main loop. Repository: C:\Projects\DashClaw You have full product authority over this repository. I am not telling you what DashClaw should be. The repo contains years of pieces — a governance runtime, capability invocation, work orders, x402 spend governance, calibration math, approvals and evidence surfaces, MCP/SDK/plugin/CLI integrations, an archived agent platform, eight roadmap eras, three fresh RFCs — and effectively zero external users. I don't know how to put the pieces together or what to get rid of, and I no longer want to decide by committee of documents. That synthesis is your job: decide what the perfect product is given everything you know, then make the repo be exactly that product and nothing else — something a person understands immediately. </mandate> <what_to_synthesize_from> Ground the decision in everything you know, not just the current tree: - Your persistent project memory (MEMORY.md and every linked memory file) and claude-mem session history — mine both fully; they hold years of context, owner feedback, and settled lessons. - docs/maintainer-log.md end to end; roadmaps v1–v8 including the archives; the RFCs; PROJECT_DETAILS.md; the archived platform era in app/api/_archive (the fossil of a previous identity — understand why it died). - The market evidence, weighted heaviest of all: launch and reach outcomes, funnel truth, the activation instrument (scripts/measurement-read.mjs), hosted-trial data, and the cohort count as of today. Zero users changes the physics: backward compatibility is nearly free to break; a reason to adopt and instant legibility are everything. - The owner's recorded desires across our history — the "one stop shop" ask, the build-for-humans contract, the governance charter, the repeated frustration with sprawl. These are inputs to weigh honestly, not orders to follow blindly. Where they conflict, resolve the conflict and say how. First deliverable, before any cull: write the product thesis as ONE canonical document that supersedes the strategy sprawl (mark everything it replaces). It must state: what the product is, for whom, why these pieces and not the others, what is explicitly out of scope, and — mandatory — what observable evidence would prove the thesis wrong. Reach it properly: generate several candidate product definitions from genuinely different lenses (what the code is strongest at, what the zero-user evidence implies, what the owner has actually asked for over time, what a stranger would pay for), judge them adversarially at scale, and commit to ONE. Do not average the candidates into mush, and do not pick by default whatever the current README says. </what_to_synthesize_from> <authority_and_limits> Yours to decide: the identity; what lives, dies, or gets demoted (routes, pages, libs, SDK methods, MCP tools, plugins, docs, marketing copy); whether the hosted trial and the July 19–20 measurement window still matter under your thesis; the sequencing; the landing timing; the version story. Not yours to break: 1. MAINTAINER.md's five human-held invariants remain binding. 2. No *** history rewrites, no force pushes. Every deletion stays recoverable by SHA. 3. A complete decision record: the thesis document plus a kill ledger (docs/releases/) listing every removed surface with a one-line rationale and the last SHA containing it. This is how I audit your judgment after the fact instead of approving during — make it exhaustive. 4. No irrecoverable data destruction: no destructive DB migrations against existing installs without a documented export/recovery path. 5. The repo ends the run WORKING: full gate suite green (lint, FULL vitest, next build, typecheck, the contract/inventory/count checks), generated artifacts regenerated via their npm scripts (never hand-edited), touched pages verified rendered. Nothing lands on main until green. 6. Ship honestly: a version bump matching the break (almost certainly a major), changelog, migration notes, maintainer-log entry, GitHub Release. Outward copy obeys claims-proven-live — no claims your own verification didn't prove. 7. Secrets rules are absolute. Credential-gated publishes (release:sdks) are my tail — prepare them, flag them, never attempt them. 8. Preflight or stop: clean working tree, the calibration controller verified landed on main, no other session mid-flight in this repo. </authority_and_limits> <orchestration_expectations> Design the workflows yourself; this is scale guidance, not a script. Synthesis: wide evidence fan-out (memory, logs, market data, code reality) → independent candidate theses → adversarial judge panels → one committed thesis, written down. Execution: total inventory with reference graphs (routes, pages, MCP tools, SDK methods, plugins, docs, root files) → keep/demote/kill verdicts, each KILL surviving an adversarial "prove removal is safe AND that keeping it would not serve the thesis" check → worktree- isolated execution per domain, every coupled surface updated together (SDKs, MCP server, plugins, CLI, examples, OpenAPI, livingcode, docs counts, marketing — a partial kill is worse than none) → verification (gates, frontend-verify on surviving pages, policy-smoke live proof, drift audit, security pass on the diff) → ship. Failures loop back to execution — fix, never file follow-ups for work you can do now. If any sweep bounds its coverage, log what it skipped. Resume interrupted workflows rather than restarting them. </orchestration_expectations> <output_format> 1. Outcome: shipped / branch-ready (and why you chose not to land) / blocked. 2. The thesis in five sentences, and where the full document lives. 3. The numbers: routes, pages, MCP tools, SDK methods, active docs, root files — before → after. 4. Kill ledger location, plus the ten biggest kills with their rationales. 5. What you decided about the hosted trial and the measurement window, and the reasoning. 6. Verification: every gate with its actual result. 7. What a stricter reading of your own thesis would also have cut, and why you kept it. 8. My tail: everything credential-gated or otherwise only mine to do. Lead with the outcome. No chain-of-thought. </output_format>

• 
  Alireza Najafi (@alire8za) reported 53 minutes ago

  @daniel_nguyenx is this an android apk? Boox note air 3 c was so laggy with non default android note taking applications. the stock app was nice and fast but the ones I installed were all laggy. Didn't you face such problem in your development? Also is this available on github?