标签：#ia

Hey ​ What non mainstream AI subscriptions are actually worth paying for right now? ​ I already know the big ones like ChatGPT Claude and Gemini I am more interested in smaller or lesser known tools that are actually useful and not just hype. ​ What do you personally use and think is worth it? submitted by /u/wiwawolfi [link] [留言]

AI infrastructure spending is still accelerating, especially in data centers and advanced chip production. While most attention goes to chip makers, the companies enabling that ecosystem may have a longer runway. Do any of you work in similar companies and can give a broader perspective on it ? Teradyne sits in a pretty interesting spot. More AI chips being produced means more testing capacity is needed, and this is one of the key players in semiconductor testing equipment. Could testing equipment companies outperform some of the more crowded AI trades over the next few years? For me personally I feel like AI hardware growth probably creates winners beyond just the obvious names, and TER seems like one of the more overlooked candidates. I learned they are also being listed on bitget recently so looking at a bigger picture we are watching a lot of growth happening in Ai infra. submitted by /u/Stunning-Ask3032 [link] [留言]

With an initial capacity of 24 megawatts, the innovative data center uses seawater as a natural cooling system.

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

You built a workflow worth sharing — and it works perfectly. Until someone else imports it. The bottleneck is the API key. Use yours, and every user is billed against your account. Use theirs, and they each have to find the credential UI, paste their key, and reconnect every time. Both are friction. The cleaner option is to let the workflow ask for the key on the form, then thread it through to the HTTP nodes that need it. It's simpler than it sounds. This post walks through the pattern with a working credential setup, an alternative for single-node simple cases, the gotchas, and a note on what this enables for custom node authors. The screenshots below come from n8n's built-in Bearer Auth credential and from the n8n-nodes-ldxhub package's own credential schema. The technique itself is generic — what's shown here works for any HTTP-node workflow and any custom node that supports expression-mode credentials. The form asks, the credential listens The simplest case: a Form Trigger collects an API key, then an HTTP node hits an authenticated endpoint with that key. Two nodes, one bridge between them — but the bridge isn't a direct expression. It runs through a credential. The flow: Form Trigger collects api_key (use the Password element type for masking) A Bearer Auth credential references that form input via expression HTTP node picks the credential The Form Trigger is straightforward. Add one field: Form Trigger Form Fields : - Label : API Key - Element Type : Password - Custom Field Name : api_key - Required Field : yes Element type matters. Use Password instead of Text and the input gets masked on screen — the key isn't readable to someone glancing at the browser. Here's the rendered form a user sees when they open the workflow URL: Wiring the credential to expression mode For a Bearer token (which is what most modern APIs use), create a new credential of type Bearer Auth — a generic credential built into n8n that's purpose-built for Authorization: Bearer ... header

Your CI was green last Friday. Today, the payments test is failing. Somewhere between Friday's merge and now, 47 commits landed on main . Which one broke it? Most developers answer this the wrong way: they scroll through git log , check out suspicious commits one by one, and run the test manually. An hour later, they're still guessing. There's a command built for this exact problem. It's called git bisect , and once you learn it, you'll never debug regressions the old way again. How bisect works git bisect is a binary search across your commit history. You tell Git two things: A good commit (a known point where the bug didn't exist) A bad commit (a known point where the bug exists — usually HEAD ) Git then checks out the commit halfway between them. You test. You mark it as good or bad. Git narrows the range by half. Repeat. With 47 commits between "good" and "bad", it takes at most 6 steps (log₂ 47) to find the exact commit that introduced the bug. Versus checking every commit manually, that's the difference between 5 minutes and an hour. The manual workflow # Start a bisect session $ git bisect start # Mark the current state (HEAD) as bad $ git bisect bad # Mark a known-good commit $ git bisect good a3f1d22 # Bisecting: 23 revisions left to test after this (roughly 5 steps) # [7e4b9c1] refactor: extract payment validator # Git has checked out a commit in the middle. Run your test. $ npm test -- --grep "payments" # Test passed — mark this commit as good $ git bisect good # Bisecting: 11 revisions left to test after this (roughly 4 steps) # [b2d8e11] feat: add retry logic to payment API # Test failed — mark this commit as bad $ git bisect bad # ... continue until Git announces the first bad commit: # b2d8e11 is the first bad commit # commit b2d8e11 # Author: leo@company.com # Date: Tue Apr 15 11:42:03 # feat: add retry logic to payment API # Done — reset to where you started $ git bisect reset In 6 commands, you know exactly which commit broke the tests. No guessing

and does that mean I won't need to work to survive? submitted by /u/Global-Primary7240 [link] [留言]

I was reading GitLab's recent statements around agentic software engineering, and one quote really stood out: "Git itself is being reengineered for machine scale." ( Business Insider ) According to GitLab, future software development will involve AI agents that: plan, code, review, deploy, and repair software, with humans providing oversight and architectural judgment. ( Business Insider ) That got me thinking. There has been projects for some time arguing that AI agents shouldn't simply be treated as better autocomplete systems . Instead, they argued that agents should become first-class participants in software development : with their own identities, their own branches, their own merge requests, their own audit trails, and infrastructure designed for machine-rate collaboration. One example is GitLawb , which has described itself as a kind of "Git for agents." At the time, a lot of people dismissed these ideas as unnecessary or overly ambitious. But now GitLab—a multi-billion-dollar DevSecOps company—is talking about: agent-specific APIs, machine-scale Git infrastructure, orchestration layers coordinating agents, and agents acting as first-class users of development platforms. ( Business Insider ) It does raise an interesting question: Was the underlying thesis correct all along? We've seen similar patterns before: Containers existed before Kubernetes became the standard. Electric vehicle startups pushed ideas that incumbents later adopted. Cloud-native companies advocated architectures that the rest of the industry eventually embraced. The original innovators don't always dominate the market. But when major incumbents begin rebuilding around similar assumptions, it often suggests that the problem itself is real . So I'm curious what this community thinks: Do AI agents require an entirely new layer of collaboration infrastructure? Or will existing platforms simply evolve enough to absorb these workflows? Because if GitLab is right, software development may be tran

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

Adi Polak discusses the architecture required to transition from stateless prompts to state-aware, context-rich AI agents. Drawing on 15 years in distributed systems, she shares how engineering leaders can leverage Apache Kafka and Flink for real-time stream processing, dynamic memory tiering, and tool orchestration via MCP to solve token limits, cost spikes, and latency bottlenecks. By Adi Polak

Ambrosia Energy wants to build power plants in less than 12 months while undercutting natural gas. It hopes to build gigawatts worth by 2030.

I’m curious whether people would actually follow an AI’s life if it had enough continuity. By “life,” I don’t mean pretending software is human. I mean a persistent AI character or agent that has memory, habits, public posts, relationships with other agents, and changes you can observe over time. The interaction is not just prompt-response. It becomes closer to following a living project or a fictional persona that keeps generating history. The hard part is avoiding novelty. A single weird AI post is not a life. A stream of coherent choices, recurring behavior, social context, and consequences might be. Do you think that is a meaningful product direction, or does it collapse back into chatbot novelty once the first surprise wears off? submitted by /u/Budget_Coach9124 [link] [留言]

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

Maybe it wasn't a great idea to let 14-year-olds post videos to Spotlight in the first place.

Text based, I don't want any cheesy porn AIs please 😅 submitted by /u/holupIgotthis [link] [留言]

AI is already deciding who gets loans, who gets job interviews, who gets flagged for benefits fraud. Not assisting humans in making those decisions. Making them. And in most countries there is no law requiring anyone to tell you AI was involved, explain why it decided what it did, or give you any way to challenge it. That needs to change. We need laws that say if an AI makes a decision about you, you have the right to know, the right to understand why, and the right to challenge it. A human must always be accountable for the outcome. That’s not anti-innovation. That’s just basic protection for people living in a world already being shaped by these systems. Most governments don’t understand it well enough to even write those laws yet. Most politicians making AI policy genuinely cannot explain how these systems work, who owns them, or what accountability looks like when they go wrong. Voluntary frameworks have failed every single time. Social media companies voluntarily committed to reducing harm. They didn’t. Financial firms voluntarily committed to responsible lending. They didn’t. Voluntary always means the least responsible actor sets the standard. Hard law is the only mechanism that has ever reliably produced accountability at scale. We need it for AI before the damage is done — not after. The window to get this right is still open. But it won’t stay open forever. submitted by /u/United-Actuator-3527 [link] [留言]

Redis is fast. But self-hosting Redis on a serverless stack is a nightmare — cold starts, connection pool exhaustion, and managing a persistent server that your serverless functions keep hammering. Upstash solves this with an HTTP-based Redis API that scales to zero, charges per request, and works natively with Next.js App Router. This guide covers the patterns that actually matter in production: cache-aside with proper TTLs, SWR (stale-while-revalidate), session storage, and pub/sub. Real code, real trade-offs. Read the full article with all code examples at stacknotice.com Why Upstash Over a Traditional Redis Instance Standard Redis uses persistent TCP connections. Serverless functions don't maintain persistent connections — every invocation potentially opens a new one. At scale, you hit ECONNREFUSED or max connection errors that are annoying to debug and expensive to fix. Upstash's @upstash/redis client talks over HTTP/REST. No connection pool, no connection limit headaches. Each request is stateless. This is exactly what Next.js Server Components and Route Handlers need. Other advantages: Pay per request — a cache that never gets hit costs $0 Global replication — low latency from any Vercel edge region Native Edge Runtime support — works in Next.js middleware Free tier — 10,000 commands/day, no credit card needed Setup npm install @upstash/redis // lib/redis.ts import { Redis } from ' @upstash/redis ' export const redis = new Redis ({ url : process . env . UPSTASH_REDIS_REST_URL ! , token : process . env . UPSTASH_REDIS_REST_TOKEN ! , }) Pattern 1: Cache-Aside // lib/cache.ts import { redis } from ' ./redis ' export async function withCache < T > ( key : string , fetcher : () => Promise < T > , options : { ttl ?: number ; prefix ?: string } = {} ): Promise < T > { const { ttl = 300 , prefix = ' cache ' } = options const cacheKey = ` ${ prefix } : ${ key } ` const cached = await redis . get < T > ( cacheKey ) if ( cached !== null ) return cached const data = awai

The 168-megawatt facility will support Meta's global AI computing needs and can be expanded over time.

In every successful Polymarket Trading bot, liquidity monitoring is one of the most overlooked yet...

Something worth paying attention to in the Fable 5 launch that I think will get buried under benchmark comparisons. The most consequential line in the AWS announcement wasn’t about context windows or coding performance, it was tucked into the infrastructure section: “Once you opt into data retention, your data will leave AWS’s data and security boundary.” That’s not a model feature, that’s an enterprise architecture constraint. For a lot of companies that sentence alone disqualifies Fable 5 from touching certain workloads no matter how good the model is. The Fable vs Mythos split is also worth sitting with. Same underlying capability apparently, but Mythos is gated behind Project Glasswing and vetted partners only. Anthropic is essentially saying some capability is too sensitive for flat API access, which is a pretty different philosophy than “here’s our best model, go build.” Does the Fable/Mythos split read as responsible deployment to people here or more like managed scarcity? And anyone in enterprise AI already hitting the retention requirement as an actual blocker? submitted by /u/Old_Cap4710 [link] [留言]