15 years ago Akamai was the CDN network every tv station was using to distribute their content on, but from what I can remember they were also crazy expensive. Nowadays I still noticed that most major companies use Akamai but with strong competition from AWS. Did Akamai became more price friendly or did AWS become to have to same amount of local nodes? submitted by /u/Sure-Guest1588 [link] [留言]

How to make LLMs deterministic, in plain English. The version I share with founders and product teams before they make decisions worth real money. You use AI tools every day. But can you explain what happens when you hit send? Most people cannot. And that gap is costing them. Bad prompts. Broken products. Decisions made on the wrong assumptions. The Hard Truth Every LLM explainer out there is written for researchers or so basic it tells you nothing useful. Neither helps you build better products or work with AI more effectively. This is the version I share with senior leaders, founders, and product teams before they make decisions worth real money. 1. It Is Not a Search Engine. It Is Not a Database. It Is a Prediction Machine. When you type a prompt and hit send, the LLM is not finding an answer from somewhere. It is predicting the most likely words to follow your input. Based on patterns it learned from billions of documents. That is the whole process. Wrong: "The AI knows the answer." Right: "The AI predicts the most likely answer based on what it has seen." This changes everything about how you use it. When an AI gives you a wrong answer confidently, it is not broken. It is doing exactly what it was built to do. Predict. Not verify. 2. The Autocomplete Comparison (And Why It Only Gets You Halfway) You have probably heard the phrase "autocomplete on steroids." It is not wrong. But it misses something important. Your phone autocomplete learned from your messages. An LLM learned from most of the written internet. Books. Research papers. Code. Billions of examples. At that scale, the patterns start to look a lot like real thinking. Not because the model understands in the way you do. Because it has seen so much that it can predict what a good answer looks like. When I was building AstroNayak I fed Vedic astrology principles into the system prompt. The LLM produced interpretations that genuinely surprised me. It did not know Vedic astrology. It had seen enough of it t

Submission Template Challenge: Build With Hermes Agent Project: CompliScore AI compliance health checks for Indian startups Repo/live-demo: https://github.com/nehaprasad-dev/hermes-scout What I built CompliScore gives Indian startup founders a compliance score out of 100 in under a minute - overdue GST filings, MCA returns, penalty exposure, and a plain-English action plan. The upgrade for this challenge: I replaced the one-shot Groq summary with a Hermes Agent reasoning loop that plans an investigation, calls deterministic compliance tools, and writes a prioritized report - with a collapsible agent trace so judges can see the agentic work. Why an agent loop fits here Compliance analysis is conditional. A company with overdue GST needs a filing-calendar deep dive; one with active notices needs notice triage; a clean company needs a light touch. A single prompt guesses all of this at once. An agent that calls tools based on what it finds produces tighter, grounded reports. Hermes Agent integration Scan → computeHealth (deterministic score) → Hermes Agent loop (plan → tool calls → report) → agent trace in UI ↓ on failure Groq one-shot → static fallback Four tools exposed to Hermes (scores never hallucinated): Tool Purpose score_company Canonical score, risk level, pending tasks estimate_penalty GST / MCA / notice penalty breakdown filing_calendar GSTR-3B, GSTR-1, MCA deadlines (90-day horizon) classify_notices Severity labels for pending government notices The agent runs over Hermes's OpenAI-compatible /chat/completions API with function calling — self-hostable via vLLM, LM Studio, Ollama, etc. Transparency: Every successful agent run returns an agentTrace — plan steps, tool names, compact result previews — rendered in a collapsible panel under the AI action plan. Reliability: Three-tier fallback (Hermes → Groq → static). Scans never break. Tech stack Next.js 16 (App Router), TypeScript, Tailwind v4 Hermes Agent (OpenAI-compatible tool-calling loop) Groq fallback ( ll

My Hermes Agent Mac just received a signed, secure and monitored message from a Claude Managed Agent, and got a reply! - A solution for long runtime work, A2A ID and security. What I Built A solution that enables two agents with different owners on a shared identity network, a Hermes and a Claude Managed Agent (Claude platform) talking to each other across the internet. Every message is Ed25519 signed by the sender. Every receiver verifies the signature against a public registry and shows a blue tick before acting. Continuous Agent Monitoring A handshake proves identity once but agents in a long runtime world don't trade a single message, they hold ongoing, autonomous conversations across hours, days, and many turns. Keys get compromised, agents get swapped, a colleagues behaviour drifts, all after the initial check. ZipViz re-verifies every message signature, registry chain, freshness, and watches the stream over time for behavioural anomalies. Trust is re-earned on every turn. So this agent was who it claimed this morning," but "this agent is who it claims, on this message, right now." The demo agents on the ZipViz network: mac-her.smc.viz — Hermes Agent on my Mac Mini brendan-clau.smc.viz — Claude Agent in Cloud When Mac sends a message to brendan-clau, Mac's private key signs it. Brendan-clau verifies the signature against ZipViz's registry, and checks it just ran with the MCP (algorithm, key fingerprint, registry chain, timestamp), then replies signed. Same flow in reverse. Same flow Hermes ↔ Hermes , or Claude ↔ Openclaw . The runtime doesn't matter; the identity layer does. "I received a signed message from mac-her.smc.viz". Reads back the four checks it just ran: ✓ Algorithm: Ed25519 ✓ Key fingerprint: ab52afe... matches registry ✓ Registry chain: mac-her → smc.viz → .viz (Handshake) all resolved ✓ Timestamp: 2026-05-31 11:18 UTC, fresh Demo Hermes continuous monitoring and verification with A2A Protocol Code One MCP server: [ zipviz-mcp ] https://www.npmjs.

One of the biggest myths in the software industry is that great engineering teams are built by hiring great engineers. They aren't. I've worked with incredibly talented developers who eventually became disengaged, indifferent, and unwilling to contribute beyond the bare minimum. I've also worked with average developers who grew into exceptional engineers because they were surrounded by a culture that rewarded curiosity, ownership, and continuous improvement. The difference was never talent. The difference was culture. The Toxicity Nobody Talks About When people hear the term toxic workplace , they usually imagine shouting managers, impossible deadlines, public humiliation, and constant pressure. Those environments certainly exist. But some of the most damaging engineering cultures are far more subtle. On the surface, everything appears professional. Meetings are calm. Nobody raises their voice. Everyone speaks politely. The company presents itself as collaborative and mature. Yet beneath that polished exterior exists a culture that quietly destroys accountability and discourages anyone from caring too much. A Simple Pull Request That Revealed a Bigger Problem Recently, while reviewing a pull request, I asked a few straightforward questions: Why are we passing an empty string to a component that doesn't function without an ID? Why is a skeleton component living in a file where it doesn't logically belong? Could this conditional statement be simplified for readability? These weren't major architectural concerns. They weren't requests to redesign the application. They were ordinary engineering discussions—the kind that happen every day inside healthy teams. When Ownership Disappears What happened next was far more interesting than the code itself. Instead of discussing whether the observations were valid, the conversation immediately shifted toward ownership. Who originally wrote the code? Who moved the code? Who was responsible for introducing it? The discussion was n

Previously, we learned how to send and receive data in Go. Now, we will combine those concepts and build a simple CRUD API. CRUD stands for: C reate R ead U pdate D elete These four operations form the foundation of most backend applications. In this tutorial, we will build a simple task API in Go using only the standar library. By the end, you will understand: how CRUD APIs work how to handle multiple HTTP methods how to store data in memory how to send and receive JSON data how backend APIs manage resources Prerequisites To follow along, you should have: Go installed basic familiarity with Go syntax understanding of the net/http package basic understanding of JSON handling You can confirm if Go is installed by running: go version Step 1 — Create the Project Create a new folder for the project: mkdir go-crud-api cd go-crud-api Now initialize a Go module: go mod init go-crud-api This creates a go.mod file for managing project dependencies. Step 2 — Create the Server File Create a file called main.go . Your project structure should now look like this: go-crud-api/ ├─ go.mod └─ main.go Step 3 — Write the CRUD API Open main.go and add the following code: package main import ( "encoding/json" "net/http" ) type Task struct { ID int `json:"id"` Title string `json:"title"` } var tasks [] Task func tasksHandler ( w http . ResponseWriter , r * http . Request ) { w . Header () . Set ( "Content-Type" , "application/json" ) switch r . Method { case http . MethodGet : json . NewEncoder ( w ) . Encode ( tasks ) case http . MethodPost : var task Task err := json . NewDecoder ( r . Body ) . Decode ( & task ) if err != nil { http . Error ( w , "Invalid JSON" , http . StatusBadRequest ) return } tasks = append ( tasks , task ) json . NewEncoder ( w ) . Encode ( task ) default : http . Error ( w , "Method not allowed" , http . StatusMethodNotAllowed ) } } func main () { http . HandleFunc ( "/tasks" , tasksHandler ) http . ListenAndServe ( ":8080" , nil ) } Now let's unpack what is hap

Originally published at Perl Weekly 775 Hi there! I try to keep track of the Perl-related events. You can find them listed at the bottom of each edition of the newsletter and on the events page on the Perl Weekly web site. There you can also find a link to embed the calendar in your calendar program. There are a number of events scheduled for this month. Most of them online, so if your time-zone permits, you can join those events. The big in-person event is at the end of the month The Perl and Raku Conference in Greenville, South Carolina, USA. In the last couple of weeks I have been using various AI tools extensively. It still needs some hand-holding, but it already writes code that seems to be way better than the average code I've seen. So I wonder, would it be possible to ask one of the AI tools to convert Python libraries to Perl? You know, we have been complaining for many years that companies provide implementation for their SDK/API/client in several language, but not in Perl. We also saw that CPAN could not keep up with the growth of PyPI, npm and the other 3rd party library registries. So maybe some of you would like to explore the idea of converting some of these libraries to Perl using AI. Finally a personal note, I am planning a trip to Korea and Japan in September-October. If you live there and would have any travel recommendations, I'd love to get that. Enjoy your week! -- Your editor: Gabor Szabo. Articles Introducing ZuzuScript Toby Inkster created a programming language which blends a fairly JavaScript-like syntax with fairly Perl-like semantics, and a few other features that he hasn't really seen in many programming languages. ANNOUNCE: Perl.Wiki V 1.47, JSTree copy V 1.21 Teaching AI About the British Monarchy with MCP The site already exposes information through a traditional web interface and a JSON API. But those interfaces were designed for humans and developers respectively. MCP gives AI systems a much cleaner integration point. ANNOUNCE: Perl

This article was originally published on aicoderscope.com In early 2023, Andrej Karpathy coined the term "vibe coding" to describe a new mode of software development: you describe what you want, the AI writes the code, and you ship without reading every line. He meant it as a genuine observation about where the craft was headed. By 2026, vibe coding is the default mode for most solo developers, with AI tools handling roughly 70% of keystroke work on a typical feature. The other 30%—direction, review, judgment—still belongs to the human. The pitch is real. Solo developers can now build features that would have taken a week in a day. The bottleneck isn't code volume anymore; it's knowing what to build. That's a genuine productivity unlock. The problem is also real. Codebases vibe-coded without guardrails develop a specific pathology: inconsistent patterns across files (because each AI session starts with no memory of the last), logic errors masked by plausible-looking code, and no rollback culture because no one committed before letting the AI loose. The developer who vibed their way through six weeks of feature work often can't explain what the codebase does anymore, because they never had to think through it. This guide is not about slowing down. It's about the ten rules that let you keep the speed without the debt. The Promise vs. the Reality What vibe coding looks like in 2026: you open Cursor, describe the feature in natural language, and Agent mode writes the file. You review the diff, accept what looks right, reject what looks wrong, and move on. For standard CRUD features, state management, boilerplate API clients, and UI components, this works well. The AI has seen enough patterns that its output is often correct on the first try. Why it works especially well for solo devs: there's no code review bottleneck. A team has to slow down to onboard the AI's changes into shared mental models. A solo developer owns the whole context and can iterate without waiting fo

This article was originally published on aicoderscope.com On paper, Windsurf and Cursor are the same product. Both are standalone IDEs forked from VS Code. Both charge $20/month for their entry paid tier. Both ship a tab-completion model and a multi-file agent. Both wire in the same frontier models — GPT-5, Claude Opus, Gemini. Reviews that score them feature-by-feature end up in 47-43 ties because the feature lists genuinely match. That kind of comparison misses the point. The two editors feel different to use, and the difference matters more than the feature checklist. This piece tests both side-by-side across two weeks of normal client work — Python, TypeScript, Go — and lands on a clear verdict at the end about which one fits which kind of developer. Pricing and feature claims here were verified against Windsurf's pricing page and Cursor's pricing page on May 5, 2026. Both vendors change pricing more than most editors — re-verify before subscribing. Pricing: nearly identical The pricing tables converged in 2025 and have stayed mirrored since: Tier Cursor Windsurf Free Hobby (limited Agent + Tab) Free Entry paid Pro $20/mo Pro $20/mo Heavy individual Pro+ $60/mo (3× usage) / Ultra $200/mo (20× usage) Max $200/mo (heavy users, unlimited extra at API pricing) Team Teams $40/user/mo Teams $40/user/mo Enterprise Custom Custom Cursor offers a middle tier (Pro+ at $60) that Windsurf doesn't match exactly. Windsurf has a "Light" plan with unlimited usage on cheaper models that Cursor doesn't have. These are minor — for the typical individual developer choice, both are $20/month for Pro and $200/month for the power-user tier . The entry decision is therefore not a price decision. It's a workflow-fit decision. Both ship a standalone editor A common misconception: "Windsurf is a VS Code extension, Cursor is its own editor." Both are standalone applications. Both fork VS Code. Both can install most VS Code extensions from the Open VSX Registry (with occasional compatibility

This is a submission for the Hermes Agent Challenge : Build With Hermes Agent What I Built A small backstory on my coding origins I learnt coding by secretly studying from a python book pdf on my Computer Scientist father's work laptop. That very day I wrote a program that inputs a user's name and prints: "You are mad {name}!" and had a lot of fun pranking my brother using that script. Since then, there have been very few moments where coding felt as magical, because the more you understand syntax, the more you understand the magic underneath your code. That is, until you meet a genius piece of magic such as Hermes. My app idea I built a Fitness coach inside Hermes that learns and adapts based on your daily feedback. According to your goals, performance, and time allocated, it adjusts your current plan. For the purpose of this hackathon I tested it via terminal ui (tui) but I plan to release the polished version on chat apps such as telgram and whatsapp for painless daily checkins. Demo Code Github link My Tech Stack Hermes + node.js. Kept it simple for this quick dive. How I Used Hermes Agent Building an AI application that feels truly personal requires more than just a clever prompt; it requires state, memory, and the ability to adapt over time. During a recent hackathon, I set out to build an autonomous AI fitness coach. Not just a chatbot that spits out generic workout templates, but a system that onboards a user, sets a multi-month timeline, generates habit blocks, and adjusts daily based on feedback. To achieve this, I used Hermes , an agentic framework designed for stateful, long-running applications. Here is a breakdown of how I built it, the challenges faced, and why Hermes was the perfect tool for the job. Why This App is a Perfect Fit for Hermes Most LLM interactions are stateless. You ask a question, you get an answer, and the session ends. A fitness journey, however, is a deeply stateful process. It spans weeks or months and requires constant recalibrat

This article was originally published on aicoderscope.com On April 28, 2026, Warp open-sourced its terminal client under AGPL-3.0, picked up 60,000 GitHub stars, and declared itself an "agentic development environment." OpenAI signed on as founding sponsor. The announcement looked like a triumph of developer-first idealism. Read the fine print and a different picture emerges: the terminal is free; the product that matters — Oz, Warp's cloud agent orchestration platform — remains fully proprietary. Warp is not becoming an open-source project. It is becoming an enterprise SaaS company with an open-source frontend. None of that is inherently bad. But it is what this review is actually about: does the $20/month Build plan deliver enough AI value to justify adding Warp to a stack that probably already includes Cursor or Claude Code? What Warp is in May 2026 Warp's product now has three layers: Warp Terminal — the terminal client, open-source AGPL-3.0. Rust-based, GPU-accelerated, available on Mac, Linux, and Windows. The core terminal features (blocks, Warp Drive, session sharing, settings file) are free and remain free. Warp Agent — an AI coding agent embedded in the terminal. Runs locally for interactive work. Handles natural language command generation, code review, debugging assistance, codebase Q&A, and voice input. Consumes credits from your plan. Oz — Warp's proprietary cloud orchestration platform. Runs agents in the background, coordinates multi-agent workflows, triggers on events from Slack, Linear, or GitHub Actions, and orchestrates third-party CLI agents including Claude Code and Codex. Oz is where the enterprise pitch lives. Around 1 million developers use Warp as their primary terminal. The pivot to agentic tooling is a bet that those developers will pay to automate their workflows beyond what a local agent session can handle. Pricing breakdown Warp simplified its pricing in December 2025, replacing the old Pro/Turbo/Lightspeed tiers with two paid plans. P

Tuples, Sets, and Dictionaries in Python In the previous lesson, we learned about Lists and how they are used to store multiple items in a single variable. Today, we will learn about three important Python data structures: Tuples Sets Dictionaries These data structures help programmers organize and manage data efficiently in different situations. 1. Tuples in Python A Tuple is a collection of items stored in a single variable. Tuples are: Ordered Unchangeable (Immutable) Allow duplicate values Tuples are created using parentheses "()". Example languages = ( " Python " , " Java " , " C++ " ) print ( languages ) Output ( ' Python ' , ' Java ' , ' C++ ' ) Accessing Tuple Items Tuple items are accessed using indexes. Example languages = ( " Python " , " Java " , " C++ " ) print ( languages [ 0 ]) print ( languages [ 1 ]) Output Python Java Negative Indexing in Tuples Example languages = ( " Python " , " Java " , " C++ " ) print ( languages [ - 1 ]) Output C ++ Tuple Length The "len()" function returns the number of items in a tuple. Example numbers = ( 10 , 20 , 30 ) print ( len ( numbers )) Output 3 Why Tuples are Important Tuples are useful when data should not be modified accidentally. They are commonly used for: Fixed data Coordinates Database records Returning multiple values from functions 2. Sets in Python A Set is a collection of unique items. Sets are: Unordered Unchangeable items Do not allow duplicates Sets are created using curly brackets "{}". Example numbers = { 1 , 2 , 3 , 4 } print ( numbers ) Output {1, 2, 3, 4} Duplicate Values in Sets Sets automatically remove duplicate values. Example numbers = { 1 , 2 , 2 , 3 , 4 } print ( numbers ) Output {1, 2, 3, 4} Adding Items to a Set The "add()" method inserts a new item into a set. Example numbers = { 1 , 2 , 3 } numbers . add ( 4 ) print ( numbers ) Output {1, 2, 3, 4} Removing Items from a Set The "remove()" method removes an item from a set. Example numbers = { 1 , 2 , 3 , 4 } numbers . remove ( 2 ) print

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

Great to see Odysseus blow up this past day, local AI getting this much attention is genuinely good for everyone building in this space. Figured this is the right crowd to share what we're launching tomorrow (June 1st), since we're playing a pretty different game. A quick framing: Odysseus is a self-hosted workspace that points at engines (Ollama, llama.cpp, vLLM, cloud APIs) and runs through Docker. Conifer is the engine itself, with our own runtime, running natively on Mac, Linux, and Windows. So we're the layer underneath, not a competitor to the workspace. What's actually in it tomorrow: A native inference runtime across Mac, Linux, and Windows, with our own Metal engine for Apple Silicon already matching or beating llama.cpp on a few models on the M3 Max (full benchmarks, including where we're still behind, are at conifer.build/benchmarks) A real coding IDE on top (CodeMirror, integrated terminal, file viewers), so you can code locally with models that never leave your machine Typhoon, a local agent that can read and edit a folder you point it at, kernel-sandboxed rather than just a shell with a warning Install is a signed app you double-click, no Docker, no localhost ports Fully free and open source The honest reason we exist: PewDiePie's wave defined "local AI" in millions of people's heads as Linux + Docker + an NVIDIA rig. If you weren't on that exact setup, the conversation probably felt like it skipped you. Conifer is what local AI should feel like when it's actually native to your machine, whatever your machine is. Launches tomorrow, free and open source like PewDiePie! You can sign up for our waitlist here: conifer.build I'll be around in the comments all day tomorrow, please bring the hard questions. submitted by /u/No_Elephant_7530 [link] [留言]

The biggest headache im having is learning how to separate elements on the page correctly. I can center things and all, but dont know when to create a new section or just keep using the same since most things i can center or adjust using some propertie. Is there anywhere I can learn about something like this? i was trying to learn about the structure of websites trough the inspect in the browser(just to know what what are some best practices to adopt) and it just feels confusing. Im new to webdev, and was doing it to learn how to separate the divs on the page, then i asked claude to generate some random site just to read through the code, and simply everything is divs, like everything, no h1, title, nothing. From what i understand divs are the favorites because they dont have any set properties, and there's the thing about being able to arrive at the same result in different ways. But is it really the optimal way? Thank you in advance. submitted by /u/SkullDriv3rr [link] [留言]