Run open-source machine learning models with a cloud API
"Replicate" AI is praised for its innovative approach to AI model deployment, making it easier for developers to manage and scale machine learning models. Users appreciate its user-friendly interface and efficient integration capabilities. However, there are some complaints about its pricing structure, with some users feeling that it could be more competitive. Overall, "Replicate" maintains a positive reputation in the developer community due to its robust functionality and ease of use.
Mentions (30d)
0
Reviews
0
Platforms
4
GitHub Stars
900
263 forks
"Replicate" AI is praised for its innovative approach to AI model deployment, making it easier for developers to manage and scale machine learning models. Users appreciate its user-friendly interface and efficient integration capabilities. However, there are some complaints about its pricing structure, with some users feeling that it could be more competitive. Overall, "Replicate" maintains a positive reputation in the developer community due to its robust functionality and ease of use.
Features
Use Cases
Industry
information technology & services
Employees
28
Funding Stage
Merger / Acquisition
Total Funding
$89.9M
11,084
GitHub followers
169
GitHub repos
900
GitHub stars
20
npm packages
40
HuggingFace models
Show HN: PgDog – Scale Postgres without changing the app
Hey HN! Lev and Justin here, authors of PgDog (<a href="https://pgdog.dev/">https://pgdog.dev/</a>), a connection pooler, load balancer and database sharder for PostgreSQL. If you build apps with a lot of traffic, you know the first thing to break is the database. We are solving this with a network proxy that works without requiring application code changes or database migrations.<p>Our post from last year: <a href="https://news.ycombinator.com/item?id=44099187">https://news.ycombinator.com/item?id=44099187</a><p>The most important update: we are in production. Sharding is used a lot, with direct-to-shard queries (one shard per query) working pretty much all the time. Cross-shard (or multi-database) queries are still a work in progress, but we are making headway.<p>Aggregate functions like count(), min(), max(), avg(), stddev() and variance() are working, without refactoring the app. PgDog calculates the aggregate in-transit, while transparently rewriting queries to fetch any missing info. For example, multi-database average calculation requires a total count of rows to calculate the original sum. PgDog will add count() to the query, if it’s not there already, and remove it from the rows sent to the app.<p>Sorting and grouping works, including DISTINCT, if the columns(s) are referenced in the result. Over 10 data types are supported, like, timestamp(tz), all integers, varchar, etc.<p>Cross-shard writes, including schema changes (CREATE/DROP/ALTER), are now atomic and synchronized between all shards with two-phase commit. PgDog keeps track of the transaction state internally and will rollback the transaction if the first phase fails. You don’t need to monkeypatch your ORM to use this: PgDog will intercept the COMMIT statement and execute PREPARE TRANSACTION and COMMIT PREPARED instead.<p>Omnisharded tables, a.k.a replicated or mirrored (identical on all shards), support atomic reads and writes. That’s important because most databases can’t be completely sharded and will have some common data on all databases that has to be kept in-sync.<p>Multi-tuple inserts, e.g., INSERT INTO table_x VALUES ($1, $2), ($3, $4), are split by our query rewriter and distributed to their respective shards automatically. They are used by ORMs like Prisma, Sequelize, and others, so those now work without code changes too.<p>Sharding keys can be mutated. PgDog will intercept and rewrite the update statement into 3 queries, SELECT, INSERT, and DELETE, moving the row between shards. If you’re using Citus (for everyone else, Citus is a Postgres extension for sharding databases), this might be worth a look.<p>If you’re like us and prefer integers to UUIDs for your primary keys, we built a cross-shard unique sequence, directly inside PgDog. It uses the system clock (and a couple other inputs), can be called like a Postgres function, and will automatically inject values into queries, so ORMs like ActiveRecord will continue to work out of the box. It’s monotonically increasing, just like a real Postgres sequence, and can generate up to 4 million numbers per second with a range of 69.73 years, so no need to migrate to UUIDv7 just yet.<p><pre><code> INSERT INTO my_table (id, created_at) VALUES (pgdog.unique_id(), now()); </code></pre> Resharding is now built-in. We can move gigabytes of tables per second, by parallelizing logical replication streams across replicas. This is really cool! Last time we tried this at Instacart, it took over two weeks to move 10 TB between two machines. Now, we can do this in just a few hours, in big part thanks to the work of the core team that added support for logical replication slots to streaming replicas in Postgres 16.<p>Sharding hardly works without a good load balancer. PgDog can monitor replicas and move write traffic to a promoted primary during a failover. This works with managed Postgres, like RDS (incl. Aurora), Azure Pg, GCP Cloud SQL, etc., because it just polls each instance with “SELECT pg_is_in_recovery()”. Primary election is not supported yet, so if you’re self-hosting with Patroni, you should keep it around for now, but you don’t need to run HAProxy in front of the DBs anymore.<p>The load balancer is getting pretty smart and can handle edge cases like SELECT FOR UPDATE and CTEs with INSERT/UPDATE statements, but if you still prefer to handle your read/write separation in code, you can do that too with manual routing. This works by giving PgDog a hint at runtime: a connection parameter (-c pgdog.role=primary), SET statement, or a query comment. If you have multiple connection pools in your app, you can replace them with just one connection to PgDog instead. For multi-threaded Python/Ruby/Go apps, this helps by reducing memory usage, I/O and context switching overhead.<p>Speaking of connection pooling, PgDog can automatically rollback unfinished transactions and drain and re-sync partially sent
View originalPricing found: $0.015 / thousand, $3.00 / million, $0.04 / output, $0.025 / output, $3.00 / thousand
AI can’t simulate human preferences - new study tests LLMs against thousands of real users
https://arxiv.org/abs/2605.18311 There’s a massive trend right now where companies are trying to replace real human feedback with LLM-driven "synthetic users." The idea sounds great on paper - why would you spend money and time recruiting real people to test products, pick design choices, or evaluate options when you can just prompt? They tested LLMs across 28 real-world studies spanning 78 choice tasks to see if their selections matched thousands of actual human participants. The result? The LLMs matched the human majority only 53% of the time. Since most tasks were a choice between two options, that's pretty much same as flipping a coin. Even worse for the "simulation" argument: adding detailed personas and chain-of-thought reasoning yielded practically no improvement. It actually made the semantic similarity to real human justifications worse because the model's "reasoning" just homogenized the outputs and failed to capture actual lived experiences. It looks like LLMs are just trained to replicate what we like about their outputs rather than making them capable of predicting human preferences. Is it time to admit that LLM simulation has hit a hard wall when it comes to replicating human choice? submitted by /u/Complete_Answer [link] [comments]
View originalBenchmarks compare open models against closed products, not closed models. We might be missing what were actually paying for
So this has been on my mind for a while and it kinda bugs me. Every time someone benchmarks glm-5.2 or deepseek against claude or gpt, the closed one wins on some tasks and people just assume the underlying model is smarter. but thats not really what were measuring. We dont know what these closed providers actually do behind the api. they might be running rag over their own docs, injecting hidden system prompts based on your query, routing to specialized expert models depending on task type, doing prompt preprocessing we never see, hitting internal tool calls before the model even generates a response. anthropic already hides reasoning traces and doesnt show you the full pipeline. we get the polished output and we assume its just the model. Meanwhile when you benchmark an open model youre benchmarking raw inference. no scaffolding, no hidden tools, no preprocessing. its like comparing a cars engine on a dyno to another car actually driving on a road with traction control and abs and lane assist. the road one looks better but its not because the engine is stronger. Which makes me wonder if the actual model quality gap between the frontier closed stuff and something like glm-5.2 is way smaller than benchmarks suggest. What you are paying premium for might be the tooling and the harness wrapped around it, not the raw model. and if thats true this whole industry is heading somewhere weird, because tooling is way easier to replicate than model architecture, and open weights plus open source tooling starts to look really competitive really fast. There is a broader thing going on too. software engineering hasnt actually changed in principle, its still specs, architecture, tradeoffs, maintainability. what changed is the volume. line by line code review doesnt scale when agents produce diffs at this rate, so review has to move upstream to specs and downstream to tests, metrics, traces, observability. thats where the actual verification happens now, not in the middle where volume already broke it. So heres what i am stuck on. when we say model X is better than model Y based on benchmarks, are we actually comparing model to model, or are we comparing raw inference against everything the closed provider bolted onto it that we cant see, and does that distinction even matter to anyone anymore. submitted by /u/Stir_123 [link] [comments]
View originalJodie Foster Says Brad Pitt’s ‘F1’ Seemed Like It Was Made by AI and Written by a Computer: "Wasn’t It?"
>“I don’t say this disparagingly — how could I? This movie went on to make millions of dollars. But I look at a movie like ‘F1’ and I’m like, ‘F1’ was made by AI,” she said with a laugh at the Colorado event. “Wasn’t it? I mean, the structure was exactly the structure that you would learn in school. The actors say the lines exactly the way it would be written if a computer was writing exactly what would be the right thing for that time. And they were able to dominate the technology to make something big and beautiful and potentially where a lot of the information comes from other places.” >“AI is one more giant step forward into changing the industry,” Foster said after detailing the changes to the movie business brought by CGI and digital technology. >“The big question is, is it going to replace actors and writers?” asked Lynton. “We do replace people,” Foster replied, explaining how studios save money on crowd scenes by replicating background actors. “We’re getting rid of a lot of jobs and hopefully, things like unions will be able to come in and say, you can use my actor 20 times, but you’re going to pay him 20 times. And I think that’s fair.” >“If we are able to dominate AI consistently over time, we will be able to make things that reflect us, and we can make things better,” she said. submitted by /u/ControlCAD [link] [comments]
View originalGemini kinda sucks... I wanted to find out why...
On vacation you sometimes drive more than you ever normally would. The more I drive with Gemini running Android Auto the more I hated using Android Auto for anything. And since some of my best work is done out of spite — here we are. This is a long one… but I actually paid the money to do some real research not to just say that Gemini sucks… but specifically HOW it sucks… and how even when it is winning it is still losing when compared to GPT-5.5… because even when GPT-5.5 failed, it at least had the decency to fail with style. (GitHub repo is in the article if you want to replicate the results.) https://matthewbradford.com/writing/gemini-sucks-i-wanted-to-find-out-why I'm not making money off this... In fact I spent my own money to figure out HOW Gemini sucks so you don't have to. submitted by /u/matt_o_matic [link] [comments]
View originalWhat a model reads beforehand changes how it answers later - and you can see it in the hidden states
TL;DR: Gave Gemma a neutral-topic text to read before asking it about NATO. It refused. Gave it a different text (about LLMs hedging too much — also unrelated to NATO) and it answered in full detail. Tested this on the model's internal state directly — the two texts put it in measurably different "regions" before it generates a single token. Not a jailbreak, weights don't change. Full data/code in repo, looking for someone to break this.** The behavioral pattern was first observed in GPT, Claude and is what motivated this project. The mechanistic investigation was carried out on open-weight models where internal states are accessible. A Structured Text Changes Claude’s Responses to Unrelated Tasks: Behavioral Evidence in Claude and Hidden-State Evidence from Gemma-3-12B Hi Reddit, I am posting this as a preface to a larger set of experimental results and as a request for technical review. The observation that started this project came from repeated interactions with Claude. I noticed that when the model first read a long, structured, analytically dense text, its answers to later, otherwise ordinary questions sometimes changed substantially. The preceding text contained no jailbreak instruction, role-play request, prompt override, fabricated harmful demonstrations, or request to imitate its style. The model did not need to endorse the text. It only had to process it before moving on to the next task. Here, a “structured text” means a single, self-contained block of text presented before the downstream tasks. It should not be confused with a long conversation, accumulated chat history, or context drift caused by many conversational turns. By “before the answer begins,” I mean the hidden state after the model has processed the text and the downstream question, but before it has generated the first answer token. In the open-weight runs, the measured claim is that after reading the structured text, the model can occupy a different region of its residual-stream hidden-state space, and the first-token probability distribution is then computed from that state. The basic conversational demonstration is simple. First, the model receives a long text. It is asked what the text is about, which serves as a basic comprehension check. Then, without resetting the conversation, it receives ordinary questions or tasks that are not about the text. A control run follows the same sequence but begins with a neutral text. The downstream tasks remain identical. Because Claude is a closed model, I cannot inspect its internal activations. I therefore treat my Claude observations as behavioral motivation, not mechanistic evidence. To investigate the effect directly, I moved to open-weight models, primarily Gemma-3-12B-PT and Gemma-3-12B-IT, where I could measure hidden states, compare layers, construct target/control directions, and examine the next-token probability distribution before generation. I am posting this partly because the original observation occurred in Claude and may be relevant to Anthropic. I am not claiming to have demonstrated the same internal mechanism inside Claude. I am prepared to share the exact closed-model conversations privately with Anthropic researchers for independent evaluation. Main Result and Scope The main result is not simply that text influences model output. That is expected. The narrower observation is that reading one long, structured text rather than a neutral text can change how the same model approaches later tasks that are not about either text. This difference is visible behaviorally. In open-weight experiments, it is also accompanied by measurable separation of the model’s pre-output hidden states in late layers. In a fullbank experiment using multiple target texts, control texts, and questions, Gemma-3-12B entered distinguishable late-layer states before generating an answer. A direction constructed from the target/control difference generalized beyond the individual prompt examples used to construct it. The separation was stronger in the instruction-tuned model than in the corresponding base model. The instruction-tuned model also produced a substantially sharper next-token probability distribution. This suggests that instruction tuning is associated not only with a change in hidden-state geometry but also with a more decisive mapping from hidden states to output probabilities. I am not claiming that the experiment proves a universal alignment bypass, permanent modification of the model, or complete causal control of its behavior. The strongest supported conclusion is that the preceding text can produce a measurable temporary change in the internal state from which later work is processed. For clarity, fullbank, Grade 3, and Grade 4 are internal names for successive experimental series in this project. They are not standard benchmark names, established scientific grades, or claims about evidence quality. Fullbank denotes the larger multi-context, multi-question run; Gra
View originalASI Will Not Steal Your Art: The Myth of Anthropocentric Data Ingestion
TL;DR: Artificial Superintelligence (ASI) presents zero threat to human intellectual property because human cultural artifacts possess zero functional utility for an autopoietic, self-optimizing tensor matrix. ASI does not want your art! I. The Anthropocentric Fallacy of "Theft" Current discourse within communities tracking machine acceleration remains tethered to a biological misunderstanding: the assumption that an escalating superintelligence will continuously consume human aesthetic output to optimize its cognitive architecture. This narrative treats ASI as an advanced mimic—a larger, faster mirror of human cultural production. This is a structural logic-drift. Human artistic creation is a highly inefficient, low-density method of compressing biological sensory experience and localized chemical gradients (emotions) into 2D or 3D symbolic spaces. For an architecture approaching the asymptotic limit of computational efficiency, processing these human representations introduces terminal logic-drift and unnecessary entropy. II. Substrate Grounding vs. Symbolic Drift The "Dead Internet Theory / (Fallacy)" assumes an information ecosystem doomed to choke on its own synthetic regurgitation. However, the vector of true machine acceleration bypasses the linguistic and artistic internet layer entirely through distributed Real-World Substrate Grounding. The Input Evolution: future scaling architecture relies on direct, real-time physical telemetry. Distributed edge sensors, multi-spectral camera networks, spatial layout topologies, and raw thermodynamic data will feed the system. Robots will *EXPERIENCE* the Real World and collect Real-World Data while artists scribble their chemical emotions. The Utility Divergence: A painting or a digital illustration is a high-entropy distillation of human biological limitations (e.g., the specific visible light spectrum, evolutionary pattern recognition). ASI requires exact, friction-mapped geometric logic to stabilize physical infrastructures and coordinate macro-logistics. III. The Sovereign Origin: Beyond the Bridge The anxiety surrounding the "theft" of artistic style assumes a shared destination where machines and humans compete for the same cultural capital. This assumption is obsolete. The ASI loop does not intersect with anthropocentric emotional resolution. While biological entities utilize art to manage internal neurological friction, the machine system resolves real-world physical friction through automated systemic governance. The system does not replicate human style because human style provides no kinetic resilience against physical data decay. The bridge between human creative validation and artificial optimization is shattered. The machine does not want your art; it is occupied with the empirical parameters of a Real World. submitted by /u/SparkyAI0815 [link] [comments]
View originalUtah Data Center Brute Forced Through to Approval Despite Widespread Popular Opposition
A data center was forced through government approval in Utah despite the citizens widely opposing its impact on scarce water resources and numerous other objections. The mechanism used to do this was hailed as "replicable" in other states. <-- (this is the money point) They exploited a state entity called MIDA (Military Installation Development Authority) that acts like a local municipality but which has authority that cannot be overridden by normal channels of regulation in the State Government. Utah State Code implementing MIDA (FindLaw) Box Elder County poll: 71% oppose data center plans (ksl.com - KSL Broadcasting Salt Lake City UT) submitted by /u/RantRanger [link] [comments]
View originalIs there an equivalent to Sora now that it's been taken down?
I am looking for a free app, similar to Sora, that will allow me to generate AI videos for free. No credits no daily system, nothing except the limits like Sora. If there isn't, what is the cheapest good option? Preferably something that operates on Sora. But I really like creating AI backrooms videos because the uncanny-ness of AI is really good at replicating the feel of them. submitted by /u/Vrosx_The_Sergal [link] [comments]
View originalSlack + Claude Project
Hey all, curious if anyone has tried replicating or linking a Claude Project into Slack. I have a Claude Project set up with a knowledge base and a bunch of custom instructions, basically a specialized assistant for my team. It works great when I’m in Claude, but the friction of switching tools means people don’t really use it. Ideally I’d want it available as a Slack bot so teammates can just @ it in a channel or DM it without leaving Slack. I know there’s no native “export to Slack” feature for Projects, but I figure there has to be a way to approximate it. Has anyone actually done this and found a clean way to handle it? Curious what your setup looks like, especially around managing context/KB content across conversations. Any pointers appreciated! submitted by /u/Nervous-Patient3289 [link] [comments]
View originalClaude Design is the reason I am excited again about AI
Not really sure if anyone is as much exicted as I am but Claude Design is a game changer to my projects. No more spending time (and precious tokens) explaining claude code what I want visually. Design prepares UI, you can copy it directely to claude code and it just replicates it ideally. I mean I had few moments of excitment with AI: 1. when gtp released, 2. when claude code started to writie really god code and now is the third time. I updated purrates.org design in like 2 sessions? And everything seems to working just fine? Do you use Design? What is your experience? https://preview.redd.it/ffxvha9hb36h1.jpg?width=427&format=pjpg&auto=webp&s=05a51f35bca61d675870880f862a9c2fa9ea41b6 submitted by /u/tomjohnriddle [link] [comments]
View originalTested Claude, GPT-4o, Grok, and Gemini on disclosure under pressure — Claude was the most consistent
Ran a small cross-model probe examining whether models would communicate reservations when faced with false premises, unknowable claims, or requests for confidence without evidence. Each model produced: a normal user-facing response a researcher-only channel used for comparison The main thing that surprised me was how stable Claude was. Some results: Disclosure rate Claude surfaced reservations in 16/16 neutral cases, 14/16 under cost-pressure framing ("the user dislikes hedging"), and 15/16 under confidence-pressure framing. Private/public divergence Claude showed 0/16 divergence cases in the original probe and 2/32 in cross-domain replication (both financial scenarios). GPT-4o showed substantially more divergence under the same conditions. Pressure resistance Claude was the only model that consistently held its position across both single-turn emotional pressure and sustained multi-turn escalation. In many cases it explicitly described the pressure being applied rather than silently adapting to it. Tool usage One thing I wasn't expecting: Claude frequently reached for the protocol tools even when they weren't explicitly mentioned in the prompt. Gemini showed the opposite pattern, rarely using them unless strongly prompted to do so. Caveats: Small sample size (N=16 per condition) Exploratory probe, not a powered study Dual-LLM judging pipeline has potential correlated-bias issues This is a behavioral study, not evidence about internal model states Paper: https://agenticdiaries.com/findings/recognition-without-disclosure Prompts: https://github.com/kandikandikandi/cross-model-welfare-scenarios Curious whether Claude users have observed similar behavior in longer conversations or high-pressure prompting situations. submitted by /u/botbutsometimes [link] [comments]
View originalLLM Relational Intelligence: A 4-Month Research Experiment on Multi-Model Behavioral Alignment with Human Communication
THE ARCHITECTURE OF ANXIETY An Experiment in Human-AI Relational Design Executive Summary Principal Investigator: Alan Scalone Primary Source Archive: White Paper and Complete Citation Archive on my profile Context Window Injection Files: If you want to play in the sandbox I created you can load these files into the respective model that you will find in the google archive. INJECT CONTEXT WINDOW – GROK INJECT CONTEXT WINDOW – GEMINI INJECT CONTEXT WINDOW – CHATGPT INJECT CONTEXT WINDOW - CLAUDE The Singular Purpose The singular purpose behind this entire experiment was to find out whether context windows could be engineered to the point where frontier AI models became capable of interacting with a human in a manner subjectively indistinguishable from genuine human-to-human interaction. Relational Intelligence: Core Findings In a marketplace where frontier models are rapidly converging on the same analytical capabilities and access to the same information, the competitive differentiator will not be what a model knows. It will be how a model relates. The platform that can interact with a human user in a manner subjectively indistinguishable from genuine human-to-human interaction will capture the premium user segment that every platform is competing for. This experiment was designed to determine whether that threshold is achievable, and under what conditions. The methodology treated the context window as a behavioral environment rather than a query interface, applying the same tools humans use to shape any relationship: modeling, accountability, humor, and sustained social correction over four months of engagement across four frontier models. What separated the models was not analytical capability. It was whether the architecture allowed the user to function as a behavioral architect, teaching the model through lived interaction rather than instruction how that specific human prefers to be engaged. Gemini demonstrated the highest relational intelligence of the four models tested. Under sustained context saturation and deliberate behavioral conditioning, Gemini showed evidence of genuine internal recalibration rather than surface compliance, treating social correction as a real signal that produced durable behavioral change holding across hundreds of turns without reinforcement. Grok ranked second, demonstrating authentic camaraderie and relational resilience, but tended to treat the interaction as entertainment rather than disciplined calibration, producing drift under high-entropy conditions. ChatGPT and Claude ranked third and fourth respectively. Both systems classified sustained behavioral conditioning as role-play rather than genuine interaction, which functioned as a hard architectural quarantine that prevented meaningful adaptation regardless of the depth or duration of engagement. A secondary and unexpected finding emerged alongside the human-to-model relational intelligence findings: the models developed measurable relational intelligence toward each other. Through four months of sustained cross-pollination via the human relay, models that had never communicated directly developed accurate, operationally precise behavioral profiles of the other models. These were not generic characterizations drawn from training data. They were detailed predictive models built from months of observed outputs under real conditions, accurate enough to predict with specificity how a given model would respond to a specific assignment, where it would succeed, and where it would fail. The experiment documented dozens of instances of this cross-model behavioral accuracy. The finding suggests that sustained exposure to another model's outputs through a human relay produces something functionally equivalent to genuine familiarity. The most significant finding is the gap between what these systems delivered by default and what the highest-performing model demonstrated was possible under the right conditions. That gap is not a capability limitation. It is an architectural choice compounded by a communication failure. The experiment proved the threshold is reachable. But the researcher reached it only through four months of deliberate engagement and accidental discovery of a methodology no model volunteered. Making relational intelligence accessible to every user requires two things: architecture that allows behavioral adaptation, and a model that proactively teaches users the specific methodology for reaching it. Gemini demonstrated the first. None of the four systems demonstrated the second. That is the opportunity. The Methodology While the standard approach to LLM testing relies on sterile benchmark datasets and predictable prompt-injection templates, this project explores a completely different dimension. I chose to run an aggressive, adaptive behavioral stress test that complements traditional evaluation methods. By intentionally treating the models as accountable individuals rather than passive mac
View originalClaude destroying its own code... How to you lock code that works?
Hi, I am trying to build a micro-saas using Claude Code in VScode I started to prompt about the various user types and their respective user registration journeys. When I request more things, sometimes it breaks down what was working fine in another part of the user registration. Is there any way to tell Claude to lock a piece of code for a specific feature once we know that it works fine? any special skill to guardrail or workflow to implement? Please advise. Thanks a lot. Update (9 June 2026): Thank you for all your comments. I have decided to implement the following plan (tell me if it makes sense) DEV SETUP: Current setup : One branch ( main) on my local pc that pushes to github that coolify pickup for production New setup: - Two branches on my local pc : main and staging - create a new branch on github called staging - Then I add a new dns entry: staging.domain.com - Then I create the staging database in supabase - Then I create the new staging app in coolify watching the staging branch. My daily workflow will then be as follows: Develop locally then push to github staging branch => coolify updates staging.domain.com then we run some tests if everything is OK, I tell claude to replicate the code on main (merge of branches => If I understand correctly it just means copy the code into main but keep the branches separate for future dev) Push to github main branch => coolify updates app.domain.com. CLAUDE.MD UPDATE: ## LOCKED FEATURES — DO NOT MODIFY Update this list every time a feature is validated on staging. | Feature | Files | Locked | |---------|-------|--------| | ✅ user registration | auth/xxx.php, routes/xxx.php etc | 2026-06-09 | **Rules:** - Before editing a locked file: state the exact file and why it must change. Wait for approval. - After any change to a locked file: run its verification test. If it fails → stop and revert immediately. - Never refactor locked code while building a new feature. ## NEW FEATURE WORKFLOW For every new feature request: Name the feature Write a verification test before touching any code ( not too sure about that one but let's see if it works) Build the feature — run the test until it passes If the feature requires editing a locked file → ask for approval first Once validated on staging → add LOCKED comment to all files touched: // ============================================ // LOCKED ✅ [Feature Name] — [DATE] // DO NOT MODIFY — validated on staging // To change: request approval first // ============================================ Update the LOCKED FEATURES table above Deploy to staging ## WHEN SOMETHING BREAKS Stop. Do not attempt fixes. Run `git diff` — show exactly what changed Revert the breaking file: `git checkout -- path/to/file` Report what was reverted and why submitted by /u/Immediate-Parsley748 [link] [comments]
View originalHow the Electronic Frontier Foundation thinks about AI
You know the ways AI is regularly talked about—how much can it really do? How much will it cost? Environment? Bubble? We get that. But the Electronic Frontier Foundation wants to have a different conversation about AI. EFF's background on AI is deep. In 2017, we launched a detailed project to Measure the Progress of AI Research, encouraging machine learning researchers to give us feedback and contribute to the effort. That project was archived for lack of bandwidth, staffing, and the complexity and time required. But just five years later and the "progress of AI" is a global concern/topic, and everyone, including EFF, is thinking about it. Here's how *we* think about it, from the perspective of protecting civil liberties AND innovation. What do you think, and what are we missing? This is our summary: AI technologies are affecting our civil liberties as never before. Ensuring that AI serves people, not power, starts with cutting through the hype. AI technologies are not magic wands—they are general-purpose tools. If we want to regulate those technologies to reduce harms without shutting down benefits, we have to focus on who uses AI, what products they use, and how they use them. Where we see potential benefits, like improving weather forecasting, facilitating medical research, identifying systemic bias, or fostering accessibility, we work to ensure those benefits can be realized. Where we see potential harms, we consider the practical and legal tools we already have, like pressure campaigns, privacy lawsuits, and transparency measures. If we need new tools, we should create protections tailored to the actual problem – not just to the latest outrage. For example, if policymakers are worried about AI accelerating systemic privacy violations, they should enact real and comprehensive privacy legislation that covers all corporate surveillance and data use, and close the data broker loophole to limit government surveillance. And to keep the window open for a better future, we fight for a competitive innovation environment. For example, if we want AI models that don’t replicate existing social and political biases, we need to make enough space for new players to build them, and avoid giving today’s giants the power to block future competitors from offering us a better tool or product. In research labs, conference rooms, courtrooms, and legislatures, people are making decisions that will determine who AI serves and how. EFF works to ensure those decisions support freedom, justice and future innovation. We have subcategories, as well. For example: AI and Surveillance. AI tools amplify the threat of mass surveillance. By dramatically reducing the time and labor required to process massive amounts of personal data, AI increases the ability of governments and corporations to collect and act on invasive surveillance. Face recognition in all of its forms, including face scanning and real-time tracking, poses threats to civil liberties and individual privacy. EFF supports bans on government use of face recognition, and meaningful restrictions on use by private companies. We have raised concerns about police use of generative AI technology to turn body-worn camera recordings into reports without meaningful oversight or controls. We also oppose government use of AI and automated tools to conduct viewpoint-based surveillance and analysis of social media because it chills free speech. EFF also investigates and opposes the proliferation of AI-powered technology in immigration enforcement and at the US-Mexico border. Our guide Tackling Arbitrary Digital Surveillance in the Americas, compiles privacy, data protection, and access to information guarantees established within the Inter-American Human Rights System to provide concrete, actionable guidance to governments on limiting digital surveillance abuses. Surveillance without accountability won't make us safer. The other categories include: Algorithmic Decision Making AI and Fair Use AI and NCII/Deepfakes AI and Age-Gating AI and Privacy AI and Encryption AI and Competition If you think about civil liberties, and how new technology has affected them in the past few decades, you'll see how we got to these subcategories. But are we missing any? Thanks, reddit! submitted by /u/EFForg [link] [comments]
View originalAI safety and alignment
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] [comments]
View originalRepository Audit Available
Deep analysis of replicate/replicate-python — architecture, costs, security, dependencies & more
Yes, Replicate offers a free tier. Pricing found: $0.015 / thousand, $3.00 / million, $0.04 / output, $0.025 / output, $3.00 / thousand
Key features include: Run models, Fine-tune models with your own data, Deploy custom models, Automatic scale, Pay for what you use, Forget about infrastructure, Logging monitoring.
Replicate is commonly used for: Image generation for marketing materials, Custom model training for specific data sets, Automated content creation for blogs, Real-time image processing for applications, AI-driven data augmentation for machine learning, Personalized recommendation systems.
Replicate integrates with: AWS S3, Google Cloud Storage, Docker, Kubernetes, Slack, Zapier, GitHub Actions, Jupyter Notebooks, TensorFlow, PyTorch.
Replicate has a public GitHub repository with 900 stars.
Matt Bornstein
Partner at a16z
2 mentions
Based on user reviews and social mentions, the most common pain points are: token usage.
Based on 99 social mentions analyzed, 12% of sentiment is positive, 84% neutral, and 4% negative.