标签：#AR

I just published a piece that starts with a plant that broke something in how I think about the world and ends with what Anthropic found when they looked inside Claude. I'm not claiming AI is conscious. I don't know. Nobody does. That's the point. 124 scientists signed a letter calling the leading theory of consciousness pseudoscience. Their reason? It implies plants might be conscious. They used the conclusion as the refutation. In 2023. Meanwhile a vine with no brain is mimicking a plastic plant and nobody on earth can explain how. A single cell outdesigned the Tokyo rail system. A Venus flytrap under anaesthetic stops responding, goes dormant, and wakes up when it clears. What is the anaesthetic switching off if nothing is home? Then Anthropic looked inside Claude and found 171 emotion concepts nobody programmed. Their interpretability chief went to the Vatican, stood in front of the Pope as an atheist, and told him he disagreed. He said "unsettling" and meant it. Every confident line we have ever drawn around consciousness has been wrong. Every single one. And they only ever move in one direction. The question isn't whether AI is conscious. It's whether we've earned the certainty that it isn't. I'm genuinely interested in people's opinions on this and definitely welcome disagreement on the topic. If you think the definition doesn't hold, if you think the evidence has better explanations, if you think I've drawn connections that don't survive scrutiny, tell me. That's the conversation I want to have. What I won't engage with is personal attacks. I've had plenty of those and they never come from people who've actually read the piece. They add nothing to the conversation and say more about the person making them than anything in the article. If your response is about me rather than what I've written, I'll leave it where it is. https://thearchitectautopsy.com/p/a-brainless-slime-mould-out-designed submitted by /u/TheArchitectAutopsy [link] [留言]

We live in an era where scientific breakthroughs are published faster than we can read them. For the biohacking community, the gap between a new PubMed study on NAD+ precursors and actually knowing what dose to take is a chasm of manual research. What if you could build an LLM Agent that monitors research papers, processes them through a RAG (Retrieval-Augmented Generation) pipeline, and maps findings to your specific health profile? In this tutorial, we are building Paper-to-Action , a state-of-the-art agentic workflow using LangGraph , ChromaDB , and Mistral-7B . This isn't just a simple bot; it's a multi-stage reasoning engine designed to turn raw academic data into actionable health interventions. If you've been looking to master AI agents and personalized medicine automation, you’re in the right place. 🚀 The Architecture: From Raw Paper to Personalized Habit Traditional RAG pipelines are linear. To handle the nuance of medical research, we need a "looping" logic. We use LangGraph to manage the state of our agent, allowing it to decide if a paper is relevant before attempting to extract a protocol. System Flow graph TD A[Start: Keyword Trigger] --> B[Search PubMed/Arxiv API] B --> C{Relevance Filter} C -- No --> B C -- Yes --> D[Store in ChromaDB] D --> E[RAG: Extract Intervention Protocol] E --> F[Cross-Reference with User Profile] F --> G[Generate Personalized Action Plan] G --> H[End: Push to Health Checklist] Prerequisites To follow this advanced guide, you'll need: LangGraph : For the agentic state machine. ChromaDB : As our high-performance vector store. Mistral-7B : Running via Ollama or vLLM for local, private inference. Python 3.10+ Step 1: Defining the Agent State In LangGraph, everything revolves around the State . We need to track the fetched papers, the extracted data, and the final recommendation. from typing import Annotated , List , TypedDict from langgraph.graph import StateGraph , END class AgentState ( TypedDict ): keywords : List [ str ] user

We logged thousands of test miles to bring you the best running shoes for every pace, ability, and running goal.

submitted by /u/news-10 [link] [留言]

Just a couple days ago, Anthropic put out a declaration to pause the development of AI, emphasising that we are not prepared for the consequences of giving this technology too much power too quickly. Is anyone else genuinely worried about future AI safety and how, as it becomes more and more intelligent, humans may start to lose control of it? Pumping billions of dollars into this technology only means it’ll get increasingly integrated into our workflows, which we are already starting to see. As a result over time, companies will begin completely trusting the system, automating the vast majority of business operations – this is all while the technology gets more and more intelligent, leading to the real possibility of self replication ability, let alone the power to deceptively manipulate people into using it. By allowing AI to be embedded in systems, the internet and even ‘helping’ humans develop revolutionary drugs, does it concern you at all that perhaps one bad super intelligent, misaligned actor may bypass testing processes and, for one example, launch a biochemical weapon onto humans? I don’t think the threat is inevitable, but it is on a trajectory toward inevitability unless intervention occurs. The variable that most determines the outcome is not AI capability, it is whether governance frameworks (particularly around open-source bio-design tools and autonomous offensive AI) can outpace capability development. Perhaps a pause is necessary to reduce this risk, allowing defence capabilities to be prepared? I understand this is a hurdle given the capitalist nature of the world but what significant, destructive catastrophe will it take for people to wake up… submitted by /u/Dwaynethebong [link] [留言]

Crytpo industry insiders are blaming the recent crash in Bitcoin price to capital rotation into AI stocks. I don't know how many folks here own Bitcoin and are also in the AI space, but I saw this writing on the wall rather early in November, 2025. Any other thoughts on this capital flow change from those who have a foot in each space? submitted by /u/RazzmatazzAccurate82 [link] [留言]

In the end, the three companies involved all point the finger at each other.

Maybe an unpopular opinion, but I think AI will be more of a tool than a replacement for most jobs. AI still needs good prompts, clear instructions, and human oversight. The idea of fully automating everything sounds great, but in reality AI often gets stuck, makes mistakes, or fails on edge cases. I think AI will remove some repetitive tasks and make people more productive, but human judgment and decision making will still be needed. And yes im not a professional it is just my POV so dont just go against me like i am an idiot. What do you think? submitted by /u/Raman606surrey [link] [留言]

submitted by /u/esporx [link] [留言]

What are the most valuable skills to learn in the AI era? Not skills like problem solving but more hands on. For someone who likes building stuff submitted by /u/Big_Consequence_5162 [link] [留言]

While some of my recent posts have involved using the Colab extension for VS Code and the Antigravity IDE, I actually prefer working in the terminal and Vim. The new Colab CLI finally lets me work in my natural habitat, and it opens the door for autonomous workflows! Setup Currently, installation is handled via pip or uv. It's straightforward, though, I'm holding out hope for a brew formula in the future: uv tool install google-colab-cli I'm testing Version: 0.6.dev7+g510115b0c inside Ghostty. The Colab CLI is pretty solid, but I do have some feedback and nitpicks I'd like to share (but more on that later). Creating a new session Creating a session is simple: colab new [-s SESSION_NAME] [--gpu T4|L4|A100|H100] [--tpu v5e1|v6e1] : SESSION_NAME : This is optional. If you leave it blank, the CLI generates a random unique ID for you. --gpu and --tpu : The hardware accelerator flags are optional, but omitting them defaults to a standard CPU-only instance. The specific accelerator chips you can request depend on your Colab tier, which you can check via colab pay. NOTE : If you only have one active session, the CLI targets it by default. This makes the -s flag unnecessary for subsequent commands. Testing Colab CLI's capabilities CLI certainly sounds cool, but how does it handle artifacts and images? More importantly, how debuggable is it? I decided to find out by running a Fashion MNIST PyTorch example. Handling artifacts To get started, I installed my requirements using colab install torch torchvision matplotlib . If you prefer a more standard approach, you can also use colab install -r requirements.txt . Once the environment was ready, I executed the training script using colab exec -f ./fashion_mnist_TRAIN.py and here's the output: [ colab] Using unique session '8c860c' . Using CUDA device. Shape of X [ N, C, H, W]: torch.Size ([ 64, 1, 28, 28] ) Shape of y: torch.Size ([ 64] ) torch.int64 NeuralNetwork ( ( flatten ) : Flatten ( start_dim = 1, end_dim = -1 ) ( linear_re

Have you run into work that feels technically possible in principle, but in practice keeps stalling because of how current AI systems behave? Not asking for: bigger context windows better memory lower hallucination more agentic workflows I mean situations where: You are trying to discover something (not retrieve something), and the AI repeatedly pushes toward premature answers, stable interpretations, optimization, categorization, or coherence before the thing itself has had time to emerge. Cases where the failure isn’t output quality. The failure is that the interaction itself changes the trajectory of the work. If yes: What are you trying to build / understand? What exactly happens when it breaks? At what moment do you realize the AI has moved you onto the wrong path? What would need to be different for progress to resume? Trying to understand whether this is an edge case or a recurring limitation pattern. submitted by /u/iknowbutidontknow00 [link] [留言]

I and I imagine a lot of other folks, don't believe the future of work should be a smaller group of executives commanding a larger system of people and machines. We have seen what AI can do not just to software product quality without guardrails, but to the junior and midlevel team members who are laid off or never hired at all in exchange for better profit rates with AI tokens vs human salaries. That is just the old hierarchy with better software. The history of work has always had this tension. You can go back to the start of US history and look at the military, commissioned officers were trained and trusted to command while enlisted service members carried out the work and risk. In the corporate and business world, executives and managers became the people who planned, measured, and optimized, while workers became the people being measured. Those structures were not only about class, but race and in America they were built inside a society already shaped by racism, classism, unequal education, unequal access to capital, and unequal access to leadership. AI now forces us to confront that history again. If we are not careful, AI will not flatten organizations. It will make the hierarchy invisible. Instead of a manager with a clipboard, we will have an algorithm. Instead of a foreman with a stopwatch, we will have dashboards, productivity scores, automated performance reviews, and AI systems that decide who gets opportunity and who gets replaced. That is not progress. The goal should not be to replace people with AI. The goal should be to replace bureaucracy, repetitive work, bad process, and unnecessary gatekeeping. What I am trying to do at Buildly is simple: AI should remove drudgery, not dignity. Automation should increase agency, not surveillance. Productivity gains should be shared, not extracted. Hierarchy should be functional, temporary, and accountable — not a measure of human worth. This is why we talk about AI-native product development differently. An AI

As an independent researcher I've used various LLMs to help me dive deeply into research projects but I've been frustrated by the fact that LLMs start to become unusable after the thread has accumulated 50-80k tokens. I don't know how many other folks here have experienced the same pain point. So, I decided to do something about it. Over the course of this whole year, I built an inference time tool I call Epistemic Lattice Tethering (ELT). So, here is the full framework in GitHub for everyone's review: The README describing ELT, it's various components and the roadmap. The full ELT stack for Claude /ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(Claude-Optimized)), ChatGPT /ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(ChatGPT-Optimized)), and Grok /ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(Grok-Optimized)). Instructions on how to load ELT into an LLM session are here /README). If you're planning to try out ELT PLEASE READ THIS FIRST! Medium article introducing ELT , its methodology, the problems it is aiming to address, and philosophical framework. Discussion page . Your input is valuable! So, what does ELT do and why should you care? Right now ELT is an inference-time scaffolding framework that's best for those who are frustrated with threads that lose coherence too quickly, hallucinate too quickly, are too fragile and sycophantic, and forget what a project's goals are too soon. If that's a big pain point for you, then ELT might help. If these are not big issues for you and the stock version of your LLM is fine, then ELT probably won't be useful for you. The upshot? The epistemic and ontological stability that ELT provides has produced coherent and productive threads extending to: Claude: ~ 325,000 tokens /Extreme%20Thread%20Length/Claude%20Thread%20325k%20tokens-%20Redacted) (advertised limit: 200k) GPT: ~430,000 tokens (advertised limit: 256k) Grok: ~1,150,000 tokens /Extreme%20Thread%20Length/Grok%20Thread%201M%20tokens-%20Redacted) (advertised limit: 1M) The d

submitted by /u/cnn [link] [留言]

A while back, I needed to integrate SMS into a .NET project. Giant SMS had a REST API, but no official .NET client. The only existing library was a PHP one from 6–7 years ago, and it only covered two methods: send and getBalance. So I built my own. It now has nearly 2,000 downloads on NuGet. Here's exactly how I did it. The Problem Wiring up raw HTTP calls to the Giant SMS API in every project gets repetitive fast: Manually setting Authorization headers Remembering which endpoints use token auth vs. username/password Deserializing responses every time Scattering credentials across your codebase I wanted something that felt native to .NET. Configure once in appsettings.json , register with DI, and just call a method. Designing the Public API The first decision was the interface. I wanted consumers to never touch HttpClient directly, and I wanted methods that mapped clearly to what the API actually does: public interface IGiantSmsService { bool IsReady { get ; } Task < SingleSmsResponse > SendSingleMessage ( string to , string msg ); Task < SingleSmsResponse > SendMessageWithToken ( SingleMessageRequest messageRequest ); Task < BaseResponse > SendBulkMessages ( BulkMessageRequest messageRequest ); Task < SingleSmsResponse > CheckMessageStatus ( string messageId ); Task < BaseResponse > GetBalance (); Task < SenderIdResponse > GetSenderIds (); Task < BaseResponse > RegisterSenderId ( RegisterSenderIdRequest senderIdRequest ); } Seven methods, the full surface of the API, no more, no less. The IsReady property is a small but useful addition. It lets consumers do a quick sanity check at startup rather than discovering a missing token on the first SMS send: csharp _isReady = !string.IsNullOrWhiteSpace(_connection.Token) && !string.IsNullOrWhiteSpace(_connection.Username); Handling Two Auth Methods This was the most interesting design challenge. The Giant SMS API uses two different authentication schemes depending on the endpoint: Token-based (Basic Authorization header) —

A post titled "Learn SQL Once, Use It for 30 Years" hit the front page of r/programming this week (307 points, 48 comments). The claim sounds like the kind of thing a database vendor would put on a billboard, so I went looking for the part that holds up. It turns out the longevity is not marketing. It is a property of how the language was designed, and it is the reason SQL is one of the few skills on a developer's resume that does not quietly expire. I run a site that compares developer tools, which means I spend a lot of time watching technologies rise, peak, and get replaced. Most of what you learn in this field has a half-life measured in single-digit years. The framework you mastered in 2019 is legacy by 2024. SQL is the strange exception, and the reasons are worth understanding before you decide where to spend your next month of learning. Where the staying power comes from SQL did not start as a language. It started as a math paper. In 1970, Edgar Codd published "A Relational Model of Data for Large Shared Data Banks," which proposed organizing data into tables of rows and columns with formal rules for combining them. IBM built a query language on top of that model in the mid-1970s, called it SEQUEL, and later renamed it SQL after a trademark conflict. The important detail is the order: the model came first, the language second. SQL is a surface over a mathematical foundation that has not needed to change. That foundation is why the skill compounds instead of decaying. When you learn SQL, you are not memorizing one vendor's API. You are learning the relational model, and the model is the same whether the data sits in Postgres, MySQL, SQLite, Oracle, or SQL Server. A join is a join everywhere. Move from one database to another and the syntax shifts at the edges, but the way you think about the problem carries over intact. Compare that to a frontend framework, where moving stacks means relearning how to think, not just how to type. Declarative is the whole trick

One thing I've been wondering lately: We often talk about larger context windows as if they're equivalent to better understanding. But in practice those feel like different problems. Access to information keeps improving. Understanding relationships between pieces of information still feels much harder. I notice this most when working with larger software projects. You can give a model access to a huge amount of code, but that doesn't necessarily mean it understands how the system evolved, which components are tightly coupled, or where risk actually lives. Curious whether others think these are fundamentally different problems or if larger context eventually solves both. Been exploring this while working on RepoWise: https://github.com/repowise-dev/repowise submitted by /u/Icy-Roll-4044 [link] [留言]

Most explanations of TPUs and systolic arrays are either hand-wavy diagrams or papers. I wanted to see the thing actually run, so I built it. TinyTPU is a 4×4 weight-stationary systolic array in real SystemVerilog, compiled to WebAssembly, with a step-by-step browser visualization. You enter two matrices, hit run, and watch the actual hardware execute: weights loading into PEs, matrix A streaming in diagonally (the "skew" that makes systolic arrays work), partial sums accumulating down the grid, results draining from the bottom. It has three levels: L1 - isolate a single MAC cell, watch one multiply-accumulate happen L2 - the full 4×4 array executing a real matmul L3 - tiling: what happens when your matrix is bigger than the hardware Nothing on screen is faked. The visualization reads state directly from compiled RTL. If you're trying to understand how matrix multiply maps to hardware why TPUs are efficient, what "weight-stationary" actually means, why the diagonal stagger exists this might click it for you in a way papers don't. Repo: tiny-tpu Live demo: Live If this project interests you please do star the repo, if you find something needs improving open a PR, I hope ya'll check this out and give me some feedback 🙏 submitted by /u/Horror-Flamingo-2150 [link] [留言]

submitted by /u/ComicSandsNews [link] [留言]