ActiveFence

ActiveFence AI

ActiveFence AI

ActiveFence AI

ActiveFence AI

ActiveFence AI

ActiveFence AI

ActiveFence AI

ActiveFence AI

ActiveFence AI

ActiveFence AI

How does Claude (with access to the law) perform compared to law-specific AI systems (like Westlaw/Lexis)? We ran a series of head to head tests

We’re now a couple of years into the AI wave, and it seems like the available legal AI technology has begun splitting down two different tracks: In one direction, there are general purpose AI systems like Claude or Chat GPT; in the other direction you have purpose-built legal AI systems like Westlaw’s AI Deep Research and Lexis Protege. We’re two active litigators (Ding and Duff) who use both Claude and Westlaw regularly. Curious to see how well the various systems perform legal research, we decided to run a series of comparison tests consisting of five prompts across all three systems. We think the results are interesting so we’ve decided to share them. By itself Claude doesn’t have access to the cases or statutes. We’ve used a connector that we built called DingDuff (it’s free for now if you supply your own Anthropic API key). As discussed below, DingDuff allows Claude to search for and retrieve cases and statutes, but the decisions about what to research or how are coming from Claude (we ran tests with and without a case law research skill file and it didn’t make a huge difference). One fascinating result of this test is it reveals how quickly Claude has improved as an AI system. These outputs were mostly generated in late April 2026 using the latest version of Claude co-work and (we think) they are very impressive. Claude could not have produced these outputs a year ago. The five prompts are made-up fact patterns designed to cover different states and different areas of law, but we tried to craft them so that they resemble real prompts we actually use. The prompts Prompt 1 Adverse Possession — Walton County, GA. Prepare a memo analyzing my client's position in a boundary dispute in Walton County, Georgia. In 1998 my client's predecessor-in-title built a barbed-wire fence intended to follow the surveyed boundary between two rural parcels. A 2024 survey revealed that the fence encroaches approximately 12 feet onto the adjoining owner's land over a 400-foot run, enclosing roughly 4,800 square feet. My client bought the property in 2011 and has continuously grazed cattle on the enclosed strip; his predecessor used it for pasture from 1998 to 2011. The record owner has paid property taxes on the disputed strip throughout. The neighbor first objected in late 2025 and has threatened ejectment. Please address: (1) whether my client can establish title by adverse possession (20-year) or prescription (7-year under color of title) under relevant Georgia statutes and case law; (2) whether tacking between predecessors is available on these facts; (3) whether the hostility element can be satisfied when the parties mutually (but mistakenly) believed the fence sat on the true line — i.e., the "mistaken boundary" line of authority; (4) the effect, if any, of the record owner's tax payments; and (5) the procedural vehicle and venue for quieting title. 2 Piercing the Corporate Veil — Single-Member Delaware LLC, Harris County forum. Please prepare a memo analyzing whether a trade creditor can pierce the veil of a Delaware LLC whose sole member is a Texas-resident individual. The LLC was formed in Delaware in 2019 to operate a single Houston-area restaurant. The sole member routinely paid personal expenses (his home mortgage, his wife's vehicle lease, his children's tuition) directly from the LLC operating account; the LLC never adopted anything beyond a one-page operating agreement, held no member meetings, and was initially capitalized with $5,000 against monthly operating expenses of roughly $80,000. My client, a produce wholesaler, is owed approximately $220,000 on open account. The LLC has ceased operations and is insolvent. Suit will be filed in Harris County. Please address: (1) whether Delaware or Texas law governs the veil-piercing analysis under Texas choice-of-law principles (internal affairs doctrine vs. substantive tort/contract characterization); (2) the substantive standards under each jurisdiction; (3) whether reverse veil-piercing is available; and (4) whether a companion Texas Uniform Fraudulent Transfer Act claim against the individual member is viable and how it interacts with the veil theory. 3 Mechanics Lien Priority — Subcontractor vs. Construction Lender, LA County. Please prepare a memo analyzing priority between my client (an HVAC subcontractor) and a construction lender on a mixed-use project in Los Angeles County. My client first furnished labor and materials on March 3, 2024, and served a 20-day preliminary notice on the owner, general contractor, and the original construction lender on March 28, 2024 (within statutory time). The original lender assigned the construction loan to a successor lender in July 2024; my client did not serve a new preliminary notice on the successor. My client last furnished work on December 15, 2024, and recorded a mechanics lien on February 10, 2025 (56 days later). The general contractor recorded a notice of completion on January 2, 2025. The s

12 Claude Code skill files I install on every new project (out of 2,300+ I've tested)

Most Claude Code skill files I see online sit in ~/.claude/skills/ and never fire. People drop them in, restart Claude Code, ask their normal questions, and Claude responds the same way it did before the install. The skill never activates. After testing 2,300 community + self-built skills over three months, here are the 6 patterns that determine whether a skill file actually loads when you need it. Sharing because I see this question come up every week and there's no single doc that covers it. Pattern 1: Specific trigger language in the description field Claude Code reads the YAML description: to decide when a skill is relevant. "Helps with database stuff" never triggers. "Use when configuring database connection pooling, choosing pool sizes, or debugging connection exhaustion" triggers reliably. The description is the skill's discoverability primitive, not flavor text. Pattern 2: One capability per file, tightly scoped A skill that tries to cover "all SQL stuff" loses to three skills that cover writing migrations, fixing injection, and explaining query plans separately. Claude's matching is roughly cosine similarity between the user's prompt and each skill's description. Diluted descriptions match weakly. Specific ones win. Pattern 3: Frontmatter conventions matter The fields Claude actually uses: name, description, category, difficulty. Optional but useful: tags. Anything else (your own custom keys) gets parsed but doesn't affect activation. Adding random metadata fields slows nothing down but doesn't help either. Pattern 4: When-NOT-to-use lists Counter-intuitive but proven: explicit "do not use this skill when..." lists make activation MORE accurate, not less. They give Claude negative examples that bound the trigger surface. Skipping this section is the most common mistake in community skill files. Pattern 5: Code examples that actually compile If your skill has a fenced code block with broken syntax, Claude leans away from the skill on activation because the example contradicts the description. Run every code block through a syntax check before saving the file. Pattern 6: Verification steps in the body Skills that include "after running this, verify by..." sections get higher activation reliability on tasks where the user is mid-execution. The verification anchor seems to help Claude decide "yes, this is the skill that matches what they're trying to do." Examples that hit all 6 patterns: Sharing 12 specific skill files from my catalog that demonstrate the patterns above, in case useful as a starting point: smart-commit — pattern 1 + 6 (specific triggers + verification) connection-pool-setup — pattern 2 (one capability) sql-injection-fix — pattern 4 (explicit when-not-to-use) redis-lua — pattern 5 (real working Lua) error-handling-audit — pattern 6 (verify after run) api-documentation — pattern 1 (very specific description) angular-rxjs — pattern 2 (one operator family) trpc-router — pattern 5 (real TS that compiles) dockerfile-generator — pattern 4 (when not to use) infrastructure-as-code — pattern 3 (clean frontmatter) custom-slash-commands — pattern 1 (trigger phrase) placebo-detector — pattern 4 (heavy when-not-to-use) They live in my catalog at clskillshub.com/browse if you want to read the actual files and see the patterns in practice. Or just write your own using the 6 patterns above, that works too. If you have a skill that won't activate, drop the description field in a comment and I'll tell you which pattern it's missing. submitted by /u/AIMadesy [link] [comments]

A Hackable ML Compiler Stack in 5,000 Lines of Python [P]

Hey r/MachineLearning, The modern ML (LLM) compiler stack is brutal. TVM is 500K+ lines of C++. PyTorch piles Dynamo, Inductor, and Triton on top of each other. Then there's XLA, MLIR, Halide, Mojo. There is no tutorial that covers the high-level design of an ML compiler without dropping you straight into the guts of one of these frameworks. I built a reference compiler from scratch in ~5K lines of pure Python that emits raw CUDA. It takes a small model (TinyLlama, Qwen2.5-7B) and lowers it to a sequence of CUDA kernels through six IRs. The goal isn't to beat Triton; it is to build a hackable, easy-to-follow compiler. Full article: A Principled ML Compiler Stack in 5,000 Lines of Python Repo: deplodock The pipeline consists of six IRs, each closer to the hardware than the last. Walking the following PyTorch code through every stage (real reference compiler output with names shortened for brevity and comments added): torch.relu(torch.matmul(x + bias, w)) # x: (16, 64), bias: (64,), w: (64, 16) Torch IR. Captured FX graph, 1:1 mirror of PyTorch ops: bias_bc = bias[j] -> (16, 64) float32 add = add(x, bias_bc) -> (16, 64) float32 matmul = matmul(add, w, has_bias=False) -> (16, 16) float32 relu = relu(matmul) -> (16, 16) float32 Tensor IR. Every op is decomposed into Elementwise / Reduction / IndexMap. Minimal unified op surface, so future frontends (ONNX, JAX) plug in without touching downstream passes: bias_bc = bias[j] -> (16, 64) float32 w_bc = w[j, k] -> (16, 64, 16) float32 add = add(x, bias_bc) -> (16, 64) float32 add_bc = add[i, j] -> (16, 64, 16) float32 prod = multiply(add_bc, w_bc) -> (16, 64, 16) float32 red = sum(prod, axis=-2) -> (16, 1, 16) float32 matmul = red[i, na, j] -> (16, 16) float32 relu = relu(matmul) -> (16, 16) float32 The (16, 64, 16) intermediate looks ruinous, but it's never materialized; the next stage fuses it out. Loop IR. Each kernel has a loop nest fused with adjacent kernels. Prologue, broadcasted multiply, reduction, output layout, and epilogue all collapse into a single loop nest with no intermediate buffers. === merged_relu -> relu === for a0 in 0..16: # free (M) for a1 in 0..16: # free (N) for a2 in 0..64: # reduce (K) in0 = load bias[a2] in1 = load x[a0, a2] in2 = load w[a2, a1] v0 = add(in1, in0) # prologue (inside reduce) v1 = multiply(v0, in2) acc0 <- add(acc0, v1) v2 = relu(acc0) # epilogue (outside reduce) merged_relu[a0, a1] = v2 Tile IR. The first GPU-aware IR. Loop axes get scheduled onto threads/blocks, Stage hoists shared inputs into shared memory, and a 2×2 register tile lets each thread accumulate four outputs at once. The K-axis is tiled into two outer iterations of 32-wide reduce. Three-stage annotations below carry the heaviest optimizations: buffers=2@a2 — double-buffer the smem allocation along the a2 K-tile loop, so loads for iteration a2+1 overlap compute for a2. async — emit cp.async.ca.shared.global so the warp doesn't block on global→smem transfers; pairs with commit_group/wait_group fences in Kernel IR. pad=(0, 1, 0) — add 1 element of padding to the middle smem dim so warp-wide loads don't all hit the same bank.kernel k_relu_reduce Tile(axes=(a0:8=THREAD, a1:8=THREAD)): for a2 in 0..2: # K-tile # meta: double-buffered, sync (small, no async needed) bias_smem = Stage(bias, origin=((a2 * 32)), slab=(a3:32@0)) buffers=2@a2 ​ kernel k_relu_reduce Tile(axes=(a0:8=THREAD, a1:8=THREAD)): for a2 in 0..2: # K-tile bias_smem = Stage(bias, origin=((a2 * 32)), slab=(a3:32@0)) buffers=2@a2 x_smem = Stage(x, origin=(0, (a2 * 32)), slab=(a0:8@0, a3:32@1, cell:2@0)) pad=(0, 1, 0) buffers=2@a2 async w_smem = Stage(w, origin=((a2 * 32), 0), slab=(a3:32@0, a1:8@1, cell:2@1)) buffers=2@a2 async # reduce for a3 in 0..32: in0 = load bias_smem[a2, a3] in1 = load x_smem[a2, a0, a3, 0]; in2 = load x_smem[a2, a0, a3, 1] in3 = load w_smem[a2, a3, a1, 0]; in4 = load w_smem[a2, a3, a1, 1] # prologue, reused 2× across N v0 = add(in1, in0); v1 = add(in2, in0) # 2×2 register tile acc0 <- add(acc0, multiply(v0, in3)) acc1 <- add(acc1, multiply(v0, in4)) acc2 <- add(acc2, multiply(v1, in3)) acc3 <- add(acc3, multiply(v1, in4)) # epilogue relu[a0*2, a1*2 ] = relu(acc0) relu[a0*2, a1*2 + 1] = relu(acc1) relu[a0*2 + 1, a1*2 ] = relu(acc2) relu[a0*2 + 1, a1*2 + 1] = relu(acc3) Kernel IR. Schedule materialized into hardware primitives. THREAD/BLOCK become threadIdx/blockIdx, async Stage becomes Smem + cp.async fill with commit/wait fences, sync Stage becomes a strided fill loop. Framework-agnostic: same IR could lower to Metal or HIP: kernel k_relu_reduce Tile(axes=(a0:8=THREAD, a1:8=THREAD)): Init(acc0..acc3, op=add) for a2 in 0..2: # K-tile Smem bias_smem[2, 32] (float) StridedLoop(flat = a0*8 + a1; < 32; += 64): bias_smem[a2, flat] = load bias[a2*32 + flat] Sync # pad row to 33 to kill bank conflicts Smem x_smem[2, 8, 33, 2] (float) StridedLoop(flat = a0*8 + a1; < 512; += 64): cp.async x_smem[a2, flat/64, (flat/2)%32, flat%2] <- x[flat/64*2 + flat%2, a2*3

9 months, 60+ cells — what I observed building with AI

I've been building a modular personal operating system on top of Claude Code for 9 months. ~60 isolated folders ("cells"), each owning one concern — text-to-speech, clipboard management, dictation, radial menu, keyboard cleaner, screenshot, GIF recording, activity tracking, and more. I run 6-8 agents daily, 8-10 hours. These are patterns I noticed over 9 months. Not rules — observations. Your mileage will vary. Heads-up: this isn't a starter guide. I'm assuming you've already been building with Claude Code (or similar) for a while. If you're just starting out, some of this may feel overwhelming — skim the headers and come back when a section clicks. For context — here's me building with a broken arm, one-handed, in Turkish: https://www.youtube.com/watch?v=Akh2RHCzab0&t=628s — not a narration of this post, just a session where some of these patterns show up in use (custom menus, voice, conv tool, invariants). The #1 thing I noticed: my input > my prompt I noticed AI doesn't follow my prompts the way I expect. What seems to happen is — AI follows ME. My brain, my real-time corrections, my navigation. I write a system prompt. My brain is in that context. I intuitively correct AI when it drifts. When I step away from that context — the prompt alone seems to fail within a few turns. I noticed this clearly when I was tired. After 8-10 hours, same system prompt, same hooks, same architecture — things started breaking. The navigation was off, the input was off. It felt like the controller was my brain, not my text. **Priority stack — what I observed matters most:** rank what what I noticed ──── ─────────────────────── ────────────────────────────────────── 1 my input brain context seemed to matter most 2 project context fractals, folder structure, existing code 3 system prompt + hooks helps, but felt less impactful than 1 and 2 4 manifest registry YAML front-matter — guessable felt better than strict 5 truth tables layer + gate — AI processes one layer at a time Fractals: AI seems to copy the nearest cell This reminded me of company culture — people sometimes copy the person next to them more than the rules document. I noticed AI doing something similar. I have ~60 folders with the same structure: Cells/{name}/ ├── MANIFEST.md ← YAML front-matter: name, platform, commands, hooks ├── product/ │ ├── engine/ ← immutable logic (switch/dispatch) │ └── runtime/ ← mutable data (seed/config/UI) └── fossil/ ← quick-access snapshots for me (git is too many hops when I need speed) When AI needs to create a new cell, I noticed it looks at the nearest existing cell and copies the pattern. No instruction needed. The convention seemed to become the instruction. (I learned later this kind of structure has a name — apparently it's called swarm architecture. I didn't set out to build one; the cell-shape just kept paying off until the system was already operating that way.) cell-browser My cell browser. 60+ folders, each with a colored icon. (1) The grid shows every cell — database, dictation, elevenlabs, speech, etc. (2) Tabs at top: Context, Logs, Commands, Transforms — for controlling the system. (3) While talking, I pick a cell and copy its context to AI. (4) Bottom tabs give different views: File Paths, Source Content, Symbols, Manifest. The MANIFEST.md registers each cell into parent cells (telegram, mac, claude) via front-matter. AI reads structured metadata instead of scanning all source code. clipboard-panel Clipboard panel. Left: searchable list of everything I copied, with timestamps. Right: rendered MANIFEST.md preview — elevenlabs cell YAML front-matter visible (type, pain, capabilities, consumer cells). This is what AI reads instead of scanning source files. What I've come to believe: **guessable + predictable felt better than strict + verbose** — for my case. Switch cases: I noticed the compiler catches more than instructions I use Swift exhaustive enums. Each state = explicit case. The compiler catches missing ones. public enum RunContext: String, CaseIterable, Sendable { case claudeCodeSession // auto-view default case claudeCodeNoSession // browse default case standalone // no Claude Code env case piped // raw output case fzfCallback // internal mechanism } conv-tool Terminal: `conv 4f7bf66f...` extracted a session — 16 turns, ~17.2k content, ~186.2k context. Token breakdown: User 1.8k (4%), Thinking 24.7k (68%), Response 5.4k (15%), Tools 2.4k (6%), Agents 1.6k (4%). Each category is a case in a Swift enum. I noticed tables seem to work better than if/else chains for me. If AI needs to handle a new case, the compiler forces it. No silent miss. I tell AI: make every state transformation obvious. When I click the record button, idle → recording. When I click stop, recording → processing. When I click cancel, recording → discarded. Every transition = explicit switch case. If I forget the context, AI can see the code and think correctly. Truth tables: every decision is a

Where’s Larry? Result of a ~12 hour autonomous Claude loop experiment.

My dog, Larry, wanders a lot and I’m often wondering where he is (I live off-grid surrounded by forest). I’ve been experimenting with a custom built autonomous Claude loop and thought I’d test it by asking it to build a system that could simply answer the question, “Where’s Larry?”. I provided the system with an initial direction prompt, access to my Home Assistant installation, Unifi camera API, and Larry’s airTag. Then I let the system run autonomously over ~12 hours and 133 Claude sessions. This video shows just a small preview of what the autonomous system created. This was just a fun experiment, to explore the potential and limits of a pure Claude Code automated build pipeline (no Open Claw). Happy to answer any questions! Features created: Real-time dog tracking using UniFi Protect camera AI detections + Apple AirTag location fusion · Claude Vision-powered photo analysis to distinguish between two visually similar dogs · Interactive satellite property map with camera FOV cones, geo-fence zones, and live position trails · Behavioral model that learns daily patterns and predicts current zone when no live data exists · Signal fusion engine combining camera detections, AirTag GPS, behavioral predictions, and spatial triangulation into one confidence-scored location answer · "Where's Larry?" natural language query API accessible via iPhone Shortcuts · Presence/away detection using AirTag home/away as a gate · Bedroom inference from negative evidence when AirTag says home but no camera has seen him · Sleep session tracking with nap detection and daily sleep budget · Self-improving recognition pipeline with profile refinement, confidence calibration, and reference photo gallery · Spatial self-tuning with per-camera bias correction and multi-camera triangulation · Auto-generated geo-fence zones from camera field-of-view data · Web dashboard with live location, zone heatmaps, activity timeline, day replay, photo journal, and movement flow visualization · Daily digest, weekly intelligence report, and morning briefing auto-generation · Smart notifications to iPhone via Home Assistant · Weather and solar correlation tracking for outdoor behavior prediction · Fully autonomous — 133 sessions, 97 sprints, ~67K lines of code, built in ~12 active hours across 4.4 days with minimal human direction About the automation system Autonomous orchestration system ("conductor") that runs Claude Code sessions back-to-back without human intervention · Three operating modes: creative (imagines and builds new features), refine (audits and improves existing code), and alternating (switches between both automatically) · Each session reads project state, proposes a sprint with 4 tasks, executes them, commits, and hands off to the next session · Sprint proposal system with quality gate — low-risk sprints auto-approve, high-risk ones pause for human approval · Suggestion inbox where the human drops ideas in plain English and the next session picks them up as priority tasks · Creative values and refine values files that guide autonomous decision-making priorities · Guardrails file that defines constraints the conductor must never violate · History deduplication log that prevents the conductor from re-proposing already-completed work · Push notifications to iPhone via Home Assistant on start, every 5 sessions, stop, and when blocked · Graceful stop signal (touch a file) that lets the current session finish before halting · Full audit trail with per-session markdown notes, sprint proposals, conductor logs, and git commits · Ran 133 sessions across 97 sprints over 4.4 days, averaging 1.2 sessions/hour (peaking at 7.3/hour overnight) · Produced 200 git commits, 160 Python modules, and ~67K lines of code from ~15 human-written suggestions submitted by /u/mrgulabull [link] [comments]