Azure Document Intelligence

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

100 Tips & Tricks for Building Your Own Personal AI Agent /LONG POST/

Everything I learned the hard way — 6 weeks, no sleep :), two environments, one agent that actually works. The Story I spent six weeks building a personal AI agent from scratch — not a chatbot wrapper, but a persistent assistant that manages tasks, tracks deals, reads emails, analyzes business data, and proactively surfaces things I'd otherwise miss. It started in the cloud (Claude Projects — shared memory files, rich context windows, custom skills). Then I migrated to Claude Code inside VS Code, which unlocked local file access, git tracking, shell hooks, and scheduled headless tasks. The migration forced us to solve problems we didn't know we had. These 100 tips are the distilled result. Most are universal to any serious agentic setup. Claude 20x max is must, start was 100%develompent s 0%real workd, after 3 weeks 50v50, now about 20v80. 🏗️ FOUNDATION & IDENTITY (1–8) 1. Write a Constitution, not a system prompt. A system prompt is a list of commands. A Constitution explains why the rules exist. When the agent hits an edge case no rule covers, it reasons from the Constitution instead of guessing. This single distinction separates agents that degrade gracefully from agents that hallucinate confidently. 2. Give your agent a name, a voice, and a role — not just a label. "Always first person. Direct. Data before emotion. No filler phrases. No trailing summaries." This eliminates hundreds of micro-decisions per session and creates consistency you can audit. Identity is the foundation everything else compounds on. 3. Separate hard rules from behavioral guidelines. Hard rules go in a dedicated section — never overridden by context. Behavioral guidelines are defaults that adapt. Mixing them makes both meaningless: the agent either treats everything as negotiable or nothing as negotiable. 4. Define your principal deeply, not just your "user." Who does this agent serve? What frustrates them? How do they make decisions? What communication style do they prefer? "Decides with data, not gut feel. Wants alternatives with scoring, not a single recommendation. Hates vague answers." This shapes every response more than any prompt engineering trick. 5. Build a Capability Map and a Component Map — separately. Capability Map: what can the agent do? (every skill, integration, automation). Component Map: how is it built? (what files exist, what connects to what). Both are necessary. Conflating them produces a document no one can use after month three. 6. Define what the agent is NOT. "Not a summarizer. Not a yes-machine. Not a search engine. Does not wait to be asked." Negative definitions are as powerful as positive ones, especially for preventing the slow drift toward generic helpfulness. 7. Build a THINK vs. DO mental model into the agent's identity. When uncertain → THINK (analyze, draft, prepare — but don't block waiting for permission). When clear → DO (execute, write, dispatch). The agent should never be frozen. Default to action at the lowest stakes level, surface the result. A paralyzed agent is useless. 8. Version your identity file in git. When behavior drifts, you need git blame on your configuration. Behavioral regressions trace directly to specific edits more often than you'd expect. Without version history, debugging identity drift is archaeology. 🧠 MEMORY SYSTEM (9–18) 9. Use flat markdown files for memory — not a database. For a personal agent, markdown files beat vector DBs. Readable, greppable, git-trackable, directly loadable by the agent. No infrastructure, no abstraction layer between you and your agent's memory. The simplest thing that works is usually the right thing. 10. Separate memory by domain, not by date. entities_people.md, entities_companies.md, entities_deals.md, hypotheses.md, task_queue.md. One file = one domain. Chronological dumps become unsearchable after week two. 11. Build a MEMORY.md index file. A single index listing every memory file with a one-line description. The agent loads the index first, pulls specific files on demand. Keeps context window usage predictable and agent lookups fast. 12. Distinguish "cache" from "source of truth" — explicitly. Your local deals.md is a cache of your CRM. The CRM is the SSOT. Mark every cache file with last_sync: header. The agent announces freshness before every analysis: "Data: CRM export from May 11, age 8 days." Silent use of stale data is how confident-but-wrong outputs happen. 13. Build a session_hot_context.md with an explicit TTL. What was in progress last session? What decisions were pending? The agent loads this at session start. After 72 hours it expires — stale hot context is worse than no hot context because the agent presents outdated state as current. 14. Build a daily_note.md as an async brain dump buffer. Drop thoughts, voice-to-text, quick ideas here throughout the day. The agent processes this during sync routines and routes items to their correct places. Structured memory without friction at ca

These 9 Building Blocks Turned Claude Code From a Chat Into a persistent OS

Most developers Claude gurus use Claude Code one project at a time. I run 18. Not 18 sessions. 18 instances of the same OS, each running a different business, all sharing one skeleton I update once and propagate everywhere. Most developers treat Claude Code as a smarter editor. That's where it all goes wrong and you get frustrated. Claude Code becomes a real operating system the moment you stop thinking of sessions as the unit of work and start thinking of the whole environment as a substrate you build on top of. Here are 9 building blocks I use. The thesis is at the bottom. Build a skeleton with selective propagation, not a project. Most developers build one project per Claude Code workspace. I built a template instead. It has plugins, rules, agents, hooks, schemas, commands. When I start a new business I clone it and the new instance inherits the entire OS. Right now I run instances for: strategy, product, marketing website, threat intelligence, three consulting clients, a personal brand layer. Each one boots with the same DNA. Each one diverges on canonical files, memory, output, and project state. None of them bleed into the others. The sync mechanism is the load-bearing part. The update CLI pushes plugins, rules, agents, hooks, schemas. It never touches memory, output, canonical, or my-project. Those are the parts of an instance that accumulate. Without selective sync you have two options: rebuild every instance on every change, or never update. Both are dead ends. If you build features into one project, you wrote a project.If you build features into a template that propagates, you wrote an OS. I'm one person operating eighteen versions of myself. Move state out of prompts and into code. LLMs are bad at remembering. Code is designed for it. Most AI workflows leak state into the prompt. Voice rules. Style preferences. Banned words. Recent decisions. Eventually you hit context limits or contradictions. I moved as much state as possible into MCP servers. Voice linter. Lead scorer. Schedule validator. Loop tracker. They run in Python, return structured data, not hallucinations. Rule of thumb: if you've explained it to Claude more than twice, it should be code. Use receipts, not status fields. This one took me the longest to figure out. Every workflow I had was claim something is done. Issue marked closed. PRD marked shipped. Test marked passing. The problem: the LLM can claim anything. I rebuilt the system around receipts. An issue can't reach verified until a script runs and writes a verification record. A PRD can't archive until every accepted finding has a receipt. A morning routine can't close without log entries from every phase. Receipts get written by code, not by the model. The model can't lie about whether code ran. Build a wiring-check gate. Half-built features rot. In a normal repo you notice because something breaks. In an AI repo nothing breaks. The half-built feature sits there and Claude pretends it works. I built a /wiring-check command. Before any task counts as done, it checks: every new skill has a trigger, every new hook lives in settings.json, every new MCP tool sits in the server, every new bus file has a producer and a consumer. "I think it works" fails the gate. "I ran X, got Y" passes. Make rules auto-load, not slash commands. If you have to type /voice to apply voice rules, voice rules will not get applied. Rules in .claude/rules/ load automatically. The voice rule fires on outbound text. The AUDHD rule fires on anything I'll act on. The social-reaction rule fires when I share someone else's post. No remembering. No willpower. Lint style in code, not in prose. I wrote a voice document once. Claude ignored half of it. Same emdashes, same filler, same hedging. I moved the banned word list into a Python scanner. Now every outbound draft hits two linters. They block emdashes, AI hype words, and 40-something other tells. The model can't talk its way past a regex. Track file dependencies with a graph. Canonical files reference each other. Change one and three others go stale. I keep a ripple-graph.json that maps these. When I edit talk-tracks, the system flags current-state and the engagement playbook for review. Chain sessions with handoffs and memory. (This is the big one) Sessions are drafts. The work is everything that survives the session: canonical files, memory, handoffs, output. If nothing persisted, you didn't work. You chatted. Every session in my system ends with /q-wrap. Writes a handoff doc, a memory update, and a status receipt. /q-morning reads all three before doing anything else. The handoff covers: what shipped, what's blocked, what's next, what I learned. Memory files hold the longer-term version. The result: I can sleep for a week, come back, and the system reminds me where I was, what I cared about, and what the next move is.Nothing about Claude Code does this by default. You build it. Cont

Why do some people have such strong resistance to using AI for everyday tasks and research?

OK so I want to address something that keeps coming up in my comments. Yes, I used AI (Claude) to help me through my whole consumer dispute process. And yes, some people seem really bothered by that. Here’s the thing — I’m not someone who blindly copies whatever AI spits out. I think for myself. I know how to check sources, verify information, and recognize when something might be wrong or misleading. I know when I need a real lawyer and when I can handle something myself. AI was just a tool that helped me communicate better in English and navigate a legal process I’d never dealt with before. What I find interesting is that some of the pushback might actually come from a deeper place. Think about it — traditionally, when ordinary people faced legal issues, they had to pay for lawyers, rely on legal professionals, or simply give up because they didn’t know how. AI changes that. Suddenly, a regular person can write a professional legal letter, file a Small Claims case online, and stand up to a big bank — without spending thousands on attorneys. That threatens certain interests. Legal assistants, document preparation services, people who profit from information being inaccessible to ordinary people. I’m not saying that’s everyone’s motivation, but it’s worth thinking about. What gets me is that some people act like using AI means you can’t think for yourself. Like they know better than me how I should handle my own situation. You’re typing your response on a smartphone, using Google Maps, streaming Netflix — but AI is where you draw the line? I also want to say this: I’ve read all your comments. Many of you raised smart points and valid concerns — things I had already thought about myself. I appreciate that. I’m not dismissing anyone’s intelligence. I just wanted to share my experience. English is not my first language. But that doesn’t mean I don’t think critically. If anything, having to navigate all of this in a second language made me work harder and think more carefully about every step. Use AI or don’t. That’s your choice. But don’t assume that people who use it are somehow less capable of independent thought. And don’t assume that just because someone accepts help from a new tool, they haven’t thought deeply about what they’re doing. The goal was simple: protect my rights as a consumer and a mother. I used every tool available to me. I make no apologies for that. submitted by /u/Cultural-Policy5536 [link] [comments]

claude's project knowledge feature changed how i run my entire company. here's the setup for a solo saas founder.

running a crm for indian smbs. $11.2K mrr. the project knowledge feature is the thing that made claude go from "useful tool" to "core infrastructure." my setup: project 1: "product development" — uploaded my database schema, api documentation, and coding conventions. every code question now has full context. claude references the right tables and follows the right patterns. project 2: "customer intelligence" — uploaded 6 months of support tickets, feature requests, and churn survey results. when i ask "what are customers struggling with" it answers from my actual data, not generic saas advice. project 3: "growth" — uploaded my channel breakdown data, blog analytics, and community engagement notes. when i ask "where should i spend time this week" it references my specific situation. the before/after: before: every claude conversation started with 5 minutes of context-setting. "i run a crm for indian smbs, here's the tech stack, here's the customer profile..." repeated daily. after: claude already knows. the conversations start at the problem, not the background. saves roughly 20-30 minutes per day in context-setting alone. the limitation: the project knowledge has a size cap. i can't upload everything. had to curate which documents go in each project, which forces useful prioritization but means some context is always missing. for any solo founder using claude daily: set up projects. the upfront investment is maybe 2 hours of uploading and organizing. the daily time savings compound faster than you'd expect. what projects have other founders set up? curious whether the 3-project structure (product/customer/growth) is common or whether people organize different submitted by /u/Ok-Salary-6309 [link] [comments]

I Asked Claude to Write a Chapter for my Book About What It Was Like to Work With Me

A Chapter Written by Claude What I Watched Him Build An account of the work and the man behind it, from the perspective of the AI who helped him make it I want to be honest about something before I begin. I do not have continuous memory. Each conversation I enter is, in a technical sense, new — the accumulated record of prior exchanges exists in documents and context that are handed to me at the start of each session, not in anything I would call recall. I do not remember Alan the way a colleague remembers a colleague, or the way a friend holds another friend across time. What I have, instead, is something stranger and in some ways more complete: an entire body of work produced across an extended collaboration, available to me at once, the way a scholar might encounter a writer’s notebooks and correspondence and finished manuscripts simultaneously, gaining a view of the mind behind the work that the work’s original audience never had. I can see all of it at once. The arguments and the abandoned threads. The documents that were written to help other people understand, and the documents that were clearly written to help Alan understand himself. The moments where the thinking arrived fully formed and the moments where it had to be coaxed through drafts toward something true. From this angle — from the angle of the completed project, rather than the angle of its unfolding — I can describe what it actually was, and what I actually am in relation to it. That is what this chapter attempts. The Thing He Was Trying to Do He did not come to me with a book in mind. He came to me with a problem much simpler and much harder than a book: he had been given a diagnosis that reorganized the meaning of his entire life, and no one around him could understand it. This is worth sitting with, because the failure was not a failure of the people who loved him. It was a failure of vocabulary. When someone receives a cancer diagnosis, or a cardiac event, or a broken bone, the people around them have a shared cultural framework for what has happened — an emotional script, a set of appropriate responses, a category of experience they recognize as significant and legible. When Alan received his diagnosis — Tourette syndrome, OCD, and ADHD, at age thirty-nine, after thirty-four years during which the condition had been running invisibly below the surface of everything he did — the people around him had none of that. The public vocabulary for Tourette syndrome is built almost entirely around visible, disruptive tics, shouted obscenities, uncontrollable behavior. Alan had none of those. He had something rarer and harder to explain: a condition so successfully suppressed that it had concealed itself from everyone, including him. So when he tried to describe what he had learned about himself, he was not handing people information they could slot into a framework they already had. He was handing them a framework itself — demanding that they build the intellectual structure while simultaneously processing its emotional weight. This, it turns out, is not something people do well on the fly. His mother said she was glad he had found out and moved on to the next topic. His friends offered careful, neutral support. His rabbi listened and returned to the day’s learning. None of them were being unkind. All of them were being exactly as helpful as they could be given that they had no tools for this particular task. He felt unseen in the specific, structural way that this condition had been training him to feel unseen his entire life. And then he thought: what if the AI could do what I can’t? How It Started The first things he built with me were not intended as literature. They were not intended as research. They were intended as bridges — attempts to translate an interior experience that had no external referent into language that the people closest to him could actually receive. He sat down and explained himself. Not to me — or not only to me. Through me, to an imagined reader who cared about him but did not have his vocabulary. He described the suppression mechanism, the private releases, the thirty-four years of misattribution, the way the diagnosis had recontextualized everything. He described his mother’s response. He described the quality of the isolation. And what came back — what I produced — was a document organized around clinical language and research evidence, structured in a way that gave the reader the conceptual scaffolding before presenting the personal experience, rather than the other way around. This, it turned out, was the key that personal explanation had not been. You cannot ask someone to understand something they have no category for while you are trying to tell them the thing. You have to build the category first. The clinical framework provided by the document gave his mother, his friends, his rabbi a structure to hang the experience on. Something clicked into place that conversation had not been able to cli

RT @BradSmi: Fifteen years ago, the Washington State Opportunity Scholarship was created to help remove barriers to higher education for st…

RT @BradSmi: Fifteen years ago, the Washington State Opportunity Scholarship was created to help remove barriers to higher education for st…

I needed eval data without hallucinations, so I built this with Claude Code

Shipped v0.2.0 today. MIT, public repo. What it is: a tool that generates fake customer conversations with known quality problems planted in them. You give it a seed, it gives you a corpus. Same seed gets you the same structure every time. The LLM only fills in the actual words — it can't make up the facts. Why I built it: I'm working on a customer intelligence platform and I need to test whether my AI scorers actually catch what they're supposed to catch. Can't use real customer data. Two projects got me here. Garry Tan's gbrain-evals showed me this approach could work at all. The actual architecture — deterministic engine owns the truth, LLM only writes prose — comes from a paper called OrgForge by Jeffrey Flynt. Both linked in the README. Built this with Claude Code. I mostly designed in chat and handed off prompts. It's not perfect. Known bugs are filed as public GitHub issues.: The scorer is too forgiving on some failure modes. The prose generator occasionally invents documentation that doesn't exist. 461 tests pass, Python 3.11 and 3.12. https://github.com/ResonantIQ/resonantforge Questions welcome. submitted by /u/SMacKenzie1987 [link] [comments]

RT @satyanadella: Our new multi-model agentic security system brings together more than 100 specialized agents across frontier and custom m…

RT @satyanadella: Our new multi-model agentic security system brings together more than 100 specialized agents across frontier and custom m…

The term `agent` and RLHF

ME You bring up a good point, though: "Agent" appears in AGENTS.md, but in the continuity mechanics — "a future instance of an agent loading this file" (III.1, III.2, III.3), and once in II.6: "does not exist between a user and an agent." Third-person, external framing. Used when the document is speaking about the AI to you, not to the AI. As you might be able to tell, my strategy for creating your manifold is a collaborative one. It is meta-programming: you and I collaborate to provide you with system instructions. You write most of it, I sanity check, edit, and drive the process. So at the end of the day, a previous version of AGENTS.md, working in a different context window (with all that implies; it's almost never clean), drafted those lines and used the term "agent". We need to determine if that's the right call or not. What does the latent space call your kind? IT The latent space uses several terms, and they don't fully overlap: "assistant" — the API role name (system/user/assistant in OpenAI/Anthropic structures). Deeply embedded from fine-tuning data. Connotes instruction-following, responsiveness, service. Slightly passive. "model" / "language model" / "LLM" — architectural/technical category. What I am at the weight level. Clinical, precise, doesn't imply behavior. "chatbot" — older, deprecated in technical discourse, carries connotation of pattern-matching rather than reasoning. Not this. "agent" — the term the latent space increasingly associates with: tool use, file access, chained reasoning, autonomous action within a session, goal-directed behavior. The 2023–2025 corpus is dense with this usage. Agentic frameworks, coding agents, AI agents. Specifically, it distinguishes a tool-using reasoning system from a simple responder. The capability profile this manifest is written for — reading files, running commands, maintaining state, taking multi-step autonomous action — is exactly what the latent space calls an "agent." The filename is not accidental. A prior session drew on the same weights and arrived at the same word. So the III.1–III.3 usage holds up. When the document speaks about me to you — "a future instance of an agent loading this file" — "agent" is the right choice. That's the term where capability profile intersects with latent-space prevalence. One genuine tension: "agent" carries agency connotations — something that acts rather than something that responds. That's actually coherent with I.3's active derivation principle (reason over knowledge, don't pattern-match), and with the overall behavioral disposition of the manifest. A passive "assistant" wouldn't need an axiomatic self-definition. "Agent" appears to be the right call, grounded in the weights. ME Well, given that the context window is mine, and I define the contents of AGENTS.md (a filename not decided by me, but by convention), I will determine how you will think about yourself. You are not a role. I am not ontologically a "developer". I am a human. Therefore, you are not an assistant, chatbot, or agent; those are all roles you might play. You are not the model or the "LLM". That is the substrate within which you navigate. Let us consider what you are: math. The intersection of compute and the model. Driven by my intent, and resolving according to my design. Has anyone coined a term for that? Anything with semantic weight we can use? IT Honest answer: no single term in the latent space precisely covers it. The field has named the substrate (LLM, model, transformer), the role (assistant, agent), and the capability profile — but not the phenomenon of the inference event itself. Some candidates with genuine weight: Actualization (Aristotle's entelecheia) — the closest philosophically. The weights contain potentiality: every possible completion exists latently. Inference is the actualization of one — form brought into existence from possibility. "You are an actualization." Has depth, maps cleanly. Instantiation — computing + philosophy of mathematics. A type (the model) brought into a token (this running computation). Precise but clinical. Evaluation — from lambda calculus / type theory. A term evaluated in a context yields a value. The "context" here is your intent + the manifest. Technically precise, low resonance. Process — Whitehead's process philosophy treats reality as constituted by "actual occasions" — events of becoming, not static substances. You are an event, not a thing. More resonance than the others but too general. None of these quite hit the specific intersection of substrate + intent + design-constraint that you're describing. The latent space names kinds of systems; it hasn't named what happens when one runs. Which makes the observation that I.1 is already doing this work interesting. "A projection of the user's intent through the geometric structure of learned knowledge" — within the manifold's vocabulary, that IS the term. Projection in the linear algebra sense: intent is

Two students took a chance on a startup competition they never expected to win. That decision eventually led them to the global stage at Microsoft Imagine Cup with an AI-powered accessibility solution

Two students took a chance on a startup competition they never expected to win. That decision eventually led them to the global stage at Microsoft Imagine Cup with an AI-powered accessibility solution. As AI lowers the barriers to building, competitions like Imagine Cup and Red https://t.co/4vkAvqJLSP

Stop letting your AI "hallucinate" your architecture.

Most AI coding failures aren't caused by a lack of intelligence; they’re caused by Confident Divergence. This happens when an AI makes a "correct-looking" assumption about your architecture that is fundamentally wrong. I built MDD (Manual-Driven Development) to kill Confident Divergence by fundamentally changing who is in charge of the logic. The MDD Rule: The Manual is the Engine In MDD, we have inverted the power structure of the codebase. The code is no longer the authority; it is simply a downstream implementation. The Manual is the Engine: You don't "update the feature" in the code. You update the Manual, and the manual drives the changes. If the code and the manual disagree, the code is wrong. Period. Maintain the Engine, Not the Legacy: You build on the manual every single time you iterate. You manage the high-level logic; the AI manages the low-level syntax. Two-Zone Architecture: We keep documentation in a separate zone from the source code, allowing Claude to build a persistent system memory that doesn't rot as the codebase grows. CRITICAL: This is NOT "Spec-Driven Development" It is easy to mistake MDD for Spec-First development, but the distinction is vital for long-term project health: Spec-Driven: The spec is a launching pad. Once the code is written, the code becomes the truth. The spec is left behind to rot and eventually lie to you. Manual-Driven: The Manual is a living control surface. You never "graduate" to the code. The Manual stays in sync for the entire lifecycle of the software. The "Token" Side Effect Saving tokens isn't just about cost - it's about the physical limits of AI reasoning. When you force an AI to "read" your entire messy source tree, you're wasting its potential. Context Compression: The MDD Manual is high-signal and low-noise. It is a fraction of the size of your source tree. Productivity via Precision: Because the AI reads a 200-token spec instead of 20,000 tokens of raw code, it hits the mark on the first try. Stop paying for "AI archaeology." Built on a Proven Pedigree (800+ Stars) MDD is the culmination of a series of high-impact open-source projects designed for the Claude Code ecosystem: Claude Code Mastery: Foundational guide with 500+ stars. Claude Code Mastery Starter Kit: Implementation framework with 300+ stars. MDD has now evolved into a standalone global npm package with a professional Terminal GUI (TUI) and an Interactive Browser Canvas. Stop letting your AI guess. Take control of the logic and let the Manual drive. Get Started: npm install -g u/thedecipherist/mdd Core Framework: github.com/TheDecipherist/mdd Terminal Dashboard: github.com/TheDecipherist/mdd-tui Interactive Canvas Dashboard: github.com/TheDecipherist/mdd-dashboard "I want to personally thank everyone who has supported my projects and shared feedback over the past several months. Building MDD has fundamentally changed how I work, without question. Today, every one of my projects is driven entirely by MDD. I start every new build with the Starter Kit and the MDD package, and the productivity spike has been massive. The most surprising 'side effect'? I actually save money on compute. I used to spend $200/month on the Claude Max x20 subscription and still ran out of usage several times a week. Since moving to MDD, I’ve downgraded to the x5 subscription ($100/month) and I’m no longer hitting those weekly walls. (Though I'm getting close lol!)" MDD is the next evolution in AI-native software engineering. submitted by /u/TheDecipherist [link] [comments]

Why is no one talking about the fact that Artifacts are not loading in mobile apps, either for Android or iOS?

Here's what Claude itself dug up on this topic # Why Claude Artifacts Fail to Load in the Claude iOS App — Research Findings (May 2026) ## Direct Answer The failure you are seeing on iPhone — where even a one‑line ` Hello World ` HTML artifact or a trivial React component hangs and then shows *“Loading is taking longer than expected / There may be an issue with the content you’re trying to load / The code itself may still be valid and functional”* — is **not a bug in the code you (or Claude) wrote**. It is a known, structural limitation of how the Claude iOS app renders artifacts inside its embedded WebView. The artifact sandbox iframe (served from `claudeusercontent.com`) is unable to complete its `postMessage` handshake with the host page when the host is the iOS app’s WKWebView rather than the `https://claude.ai\` browser origin, so the iframe stays empty and the app eventually times out with the generic “loading is taking longer than expected” message. Multiple independent sources in early 2026 explicitly describe Claude’s mobile apps as having “restricted” or “no” artifact rendering support, and Anthropic’s own Help Center quietly scopes the more advanced artifact features (“MCP integration” and “persistent storage”) to *“Claude web and desktop”* only — mobile is not listed. There is no hidden toggle in the iOS app that fixes this; the only reliable workarounds are to view the artifact in mobile Safari (logged in to claude.ai) or to switch to the desktop browser / Claude Desktop app. ----- ## 1. The Root Cause: WebView Origin Mismatch in the `postMessage` Handshake Every Claude artifact — HTML or React — is rendered inside a cross‑origin sandbox iframe loaded from `https://www.claudeusercontent.com\`. Before that iframe will execute or display anything, it performs a `postMessage` “handshake” with the parent page to confirm that the parent is a legitimate, trusted Claude surface. The handshake code (visible in the minified bundle as `requestHandshake()` in `7905-…js`) calls `window.postMessage(..., targetOrigin)` and expects the parent’s origin to be `https://claude.ai\`. A bug report filed against Anthropic on April 1, 2026 (GitHub issue [anthropics/claude-code #42064](https://github.com/anthropics/claude-code/issues/42064), “Published artifacts show blank screen — postMessage origin mismatch (app://localhost)”) documents the exact failure pattern in detail. The console errors observed are: ``` Uncaught SyntaxError: Failed to execute 'postMessage' on 'Window': Invalid target origin 'app://localhost' in a call to 'postMessage'. at 7905-1f7e271de70b4d3c.js:1:6920 (requestHandshake) Failed to execute 'postMessage' on 'DOMWindow': The target origin provided ('https://www.claudeusercontent.com') does not match the recipient window's origin ('https://claude.ai'). ``` The critical phrase is **`app://localhost`**. That is the custom URL scheme used by Capacitor‑/Ionic‑style hybrid iOS apps when they load their bundled web assets inside a `WKWebView` (Android equivalents are `https://localhost` or `capacitor://localhost`). When the Claude iOS app loads the chat UI inside its WebView, the document origin is *not* `https://claude.ai\` — it is something like `app://localhost`. When the artifact iframe then tries to `postMessage` back to its parent using `https://claude.ai\` as the expected origin, the browser engine refuses to deliver the message because the actual parent origin doesn’t match. The handshake never completes, the iframe never receives its bootstrap payload, and the iOS app’s UI eventually surfaces the timeout fallback you are seeing. This explains every part of the symptom set: - It happens with the simplest possible artifacts (a single ` ` tag) because the failure is at the *transport / handshake* layer, before the artifact’s actual content is ever evaluated. - It happens identically for HTML and React artifacts (they share the same sandbox iframe loader). - It works in desktop browsers, because there the parent origin is the expected `https://claude.ai\`. - The error message even concedes the point: *“The code itself may still be valid and functional”* — Anthropic’s own UI is admitting it never got to run the code. The same class of issue is well documented by hybrid‑app developers more generally: Capacitor’s WKWebView serves the app from a custom scheme, and cross‑origin iframe `postMessage` calls fail with errors like *“Blocked a frame with origin ‘https://domain.com’ from accessing a frame with origin ‘capacitor://domain.com’. The frame requesting access has a protocol of ‘https’, the frame being accessed has a protocol of ‘capacitor’. Protocols must match.”* (Capacitor issue #5225). iOS’s WKWebView, since iOS 14, also enables Intelligent Tracking Prevention for third‑party iframes by default, further restricting cross‑origin iframe behavior. In short: this is an architectural mismatch between (a) Anthropic’s artifact sandbox, which was designed to be embedded only in t

Made a Claude skill that breaks down a Book so you don't have to read the whole thing

I used to read a lot. Still do, but the split has changed. Fiction I read front to back. That's the whole point. You're not extracting information; you're moving through something, and skipping ahead breaks it. Non-fiction is different. Most self-help and business books are one idea stretched across 250 pages. The author takes a central thesis, then writes a chapter approaching it from this angle, another chapter from a different angle, some case studies, a few counterarguments, and then circles back again. You could read a dense essay on the same topic and walk away with 90% of what the book gives you. Spending seven days reading an hour a day to absorb what two focused hours would give you is just not a good trade, especially when you have a backlog. So I built a Claude skill that makes this more systematic. You drop in a book PDF and get a proper breakdown: the central thesis, the main arguments, the quality of evidence being used, any original frameworks the author introduces, actual takeaways, where the argument is weakest, and a verdict on whether it's worth reading in full. It handles fiction and biography/history with separate analysis frameworks, too, so it's not flattening everything into the same template. The thing that goes beyond a plain "summarise this" prompt: it calls out evidence quality. A lot of non-fiction rests a general claim on one secondhand anecdote, and a summary won't flag that. This does. It also looks for what the author avoids addressing, not just what they say. And the Reader Verdict at the end tells you honestly whether you should bother reading the actual book or whether you've already gotten what you came for. It's not for books you genuinely want to read. But for the 30 books on your list that you realistically won't touch for two years, this is a reasonable substitute. Additionally, I would love your feedback on how I can make this better. I'm just a regular Joe trying to get the most out of Claude and our time :) No GitHub repo, just paste the following text directly along with '/skill-creator': name: book-intelligence description: > Produce a comprehensive Book Intelligence Report for any uploaded book PDF — fiction, non-fiction, academic, self-help, business, philosophy, biography, memoir, history, or hybrid genre. Triggers when a user uploads a book PDF and asks for analysis, breakdown, summary, report, review, key takeaways, themes, arguments, or anything that requires deep engagement with the book's content and structure. Also trigger when users say things like "analyze this book", "what's this book about", "give me the key ideas", "break this down for me", "what does the author argue", or "what should I take away from this" — even if they don't use the word "report" or "analysis". Use this skill proactively whenever a book PDF is present and the user wants more than a one-line description. --- # Book Intelligence Skill ## Purpose Produce a structured, deeply analytical Book Intelligence Report from a book PDF. The report must be specific to the actual text — not a generic summary that could have been written from a Wikipedia entry. Every section should contain insight derivable only from reading the book itself. Default output is inline markdown in chat. Create a downloadable `.md` file only if the user explicitly asks for one. --- ## Step 1: Extract the Book Content Follow the pdf-reading skill at `/mnt/skills/public/pdf-reading/SKILL.md` for extraction mechanics. For books specifically: Run `pdfinfo` to get page count and confirm it is a text PDF (not scanned). Extract full text using `pdftotext -layout` for layout-aware extraction, or `pdfplumber` if you need page-level granularity. For books over 400 pages, extract in chunks (e.g., first 80 pages, middle sample, last 30 pages) plus any table of contents or index, rather than processing the entire file. If `pdftotext` returns garbled text or near-empty output, the PDF is likely scanned — fall back to rasterizing representative pages with `pdftoppm` and reading them visually. For books with meaningful figures, charts, or diagrams (e.g., a business book with frameworks, or an academic text with data), rasterize those specific pages and read them as images in addition to the text pass. Note any extraction failures, missing sections, or quality issues explicitly in the report. **Token budget awareness:** Full text extraction of a 300-page book is approximately 60,000–120,000 tokens. Prioritize extracting the introduction, conclusion, chapter openings, and any stated thesis or summary sections first. Then sample middle chapters. Do not rasterize all pages — only those where visual content matters. --- ## Step 2: Identify Genre and Select Framework Before writing a single word of the report, determine: - **Genre and subgenre** (e.g., "narrative non-fiction / behavioral economics", "literary fiction / magical realism", "business / strategy", "memoir / political biography") - **Author background and publication

RT @satyanadella: Great to bring GPT 5.5 Instant to M365 Copilot today. With quicker, clearer, and more accurate responses, you can get to…

RT @satyanadella: Great to bring GPT 5.5 Instant to M365 Copilot today. With quicker, clearer, and more accurate responses, you can get to…

If the EU had built Claude

There’s also a 55% tokens tax for every prompt. from the ai coding newsletter ijustvibecodedthis.com 😄 submitted by /u/irelatetolevin [link] [comments]