标签：#ai

Copilot now bills usage at listed API rates. Compare direct model access with the coding workflow, policy, and harness work around it. The post Copilot vs. raw API access: What are you actually paying for? appeared first on The GitHub Blog .

Round and round we go Gaining an advantage in AI design workflow's isn't based on better prompting. It's something we've been doing for decades... First off, this isn’t an "AI is taking my job" post. It’s a "who’s already got an edge?" post. As AI settles into creative workflows, a divide is opening up. Some people consistently get better results. Experience helps, but something deeper is at play... an insight sitting in plain sight. Enter the Art Director I’ve never carried the title, but I’ve worked with enough Art Directors to appreciate their superpower. It isn’t simply seeing the vision... it’s being able to articulate it. They instinctively know how to explain why something isn’t working and what needs to change. They choose words that shape an idea. Words that push, pull, tighten, soften, emphasize, and refine . Think about a typical creative brief. It rarely says, "Make a brochure." It says: "The typography should feel established, but not corporate." "Give the layout room to breathe." "The call-to-action should feel confident, not aggressive." None of those are technical instructions. They're creative direction. Today, the prompt bar is simply a new creative brief. Those same words can guide an AI model to the same destination. Prompt Seekers Lament Sometimes we become prompt seekers, searching for a magical combination of words that will produce perfection on the first try. Anyone in design knows how unrealistic that is. The first concept is rarely the finished concept. Designer presents, client reacts, designer refines, client reacts again... and round you go. Iteration wasn't a workaround. It was the process all along. Yet the trend on X is always some eye-catching image with everyone asking for the "one-and-done" prompt. AI is great at creating options. It's much less impressive at knowing which option is right. Cue the Director Instead of saying, "Something isn't right," an Art Director diagnoses the problem: "The composition is balanced, but the visua

Uber is also investing in Travis Kalanick's company Atoms, which has made gauzy claims about using industrial AI to modernize the world.

Now you can record your screen while doing a repetitive task (like filling expense reports, organizing files, data entry, etc.) and explain out loud step-by-step what you're doing. Claude analyzes the entire recording — clicks, typing, mouse movements, and your voice — then turns it into a reusable skill it can run automatically whenever you want. Just look for " Record a Skill " in the + menu of the Claude desktop app . Available on Pro, Max , and Team plans . This is actually game-changing 🔥 Claude #Anthropic #AICoworker

I wanted to use web-based AI chatbots — Claude, Gemini, ChatGPT, Qwen — for actual development work, not just Q&A. The free tiers are generous, and I didn't want to be locked into a single coding agent or pay for API access just to get an assistant to touch my code. But the moment you try to actually use a web chat for real dev work, you hit the same wall every time: you either paste in your whole codebase manually every session, or you give up and reach for a paid extension with an API key behind it. So I built AI Bridge — a CLI tool that bridges a local codebase and any browser-based AI chatbot. No API keys, no extensions running in the background, no vendor lock-in. You pack your code, paste it into whichever AI chat you're using, and apply the changes back with a command. Why not just use Copilot, Cursor, or an API key? Coding agent apps and API-based tools work, but they come with tradeoffs I wanted to avoid: Web-based AI chat plans are usually more generous on the free tier than API usage I'm not locked into one provider — I can switch models mid-project depending on which one is handling a task better There's no background agent or extension — it's just a CLI and whatever chat tab I already have open The tradeoff is that browser chats don't have direct filesystem access. AI Bridge closes that gap without turning it into full manual copy-pasting. How it works There are two modes, depending on project size. Simple Mode is for projects small enough to fit in a single prompt. You pack the codebase, upload it along with a couple of prompt templates, and apply the AI's response back to your files: dotnet tool install --global Tools.AIBridge cd /path/to/your-project ai-bridge init ai-bridge pack # Upload ai-bridge/1-SimpleMode/*.md + the generated context files to your AI # Copy the AI's response, then: ai-bridge apply --paste Advanced Mode is for larger codebases, where uploading everything every time burns tokens and adds noise. Instead, you generate a one-time in

ChatGPT allegedly offered "extremely dangerous medical recommendations" regarding a pulmonary embolism.

Workflows is a Rust library crate (not a hosted service; the crate name on crates.io/GitHub is tinyflows) that models an automation as a WorkflowGraph: a directed graph of typed nodes and edges. You build or generate that graph, it gets structurally validated, compiled into an opaque CompiledWorkflow, and lowered — once per run — onto tinyagents, a state-graph execution engine, via engine::run. model::WorkflowGraph -> validate -> compiler::compile -> engine::run (typed graph) (structural) (validated handle) (lowers onto tinyagents, drives to done) Run state is a single JSON value shaped like { "run": { "trigger": … }, "nodes": { "": { "items": [ … ] } } }. A merge reducer folds each node's output under its own id, so independent branches never collide — which is what keeps parallel fan-out deterministic. The node catalog Kind What it does trigger Entry node that starts the workflow (exactly one per graph); firing mode is host-driven agent Runs an LLM agent turn, with optional chat-model / memory / tool / output-parser sub-ports tool_call Invokes one specific integration action deterministically, no LLM involved http_request Outbound HTTP request code Sandboxed user code (JavaScript or Python) output_parser Parses/validates an upstream agent's output into a structured shape sub_workflow Runs another workflow as a nested sub-graph and returns its output condition Two-way IF, emits on true/false switch Multi-way branch keyed by an expression result merge Fan-in barrier — waits for every wired predecessor before running split_out Fan-out — emits one item per element of a list transform Pure, expression-based field mapping over the run state Data flows between nodes as arrays of items shaped { json, binary?, paired_item? } — closer to n8n's item-based model than a plain function-composition DAG — and node config can reference the run scope with =-prefixed expressions like =item.name. The part I actually want to talk about: host-agnosticism Every place this engine would n

OpenAI, Anthropic, and Google expose different APIs, message formats, tool-calling conventions, error types, and response structures. That difference is manageable while an application uses only one provider. It becomes more expensive when the application needs retries, circuit breakers, fallback routes, observability, and recovery across several providers. Without a shared abstraction, resilience logic tends to be implemented repeatedly: OpenAI integration ├── request conversion ├── retry logic ├── error classification ├── circuit breaker └── tool-call recovery Anthropic integration ├── request conversion ├── retry logic ├── error classification ├── circuit breaker └── tool-call recovery Google integration ├── request conversion ├── retry logic ├── error classification ├── circuit breaker └── tool-call recovery I did not want to build resilience three times. I wanted to define the recovery policy once and apply it across every provider supported by the application. That became llm-api-resilience , a Python library for retries, ordered failover, circuit breakers, and checkpoint recovery across multiple LLM providers. Quick start pip install llm-api-resilience Once the provider adapters are configured, an ordered fallback plan takes only a few lines: from llm_api_resilience import RecoveryPlan , ResilientLLM , Route llm = ResilientLLM ( RecoveryPlan ( [ Route ( " openai-primary " , openai_adapter ), Route ( " anthropic-backup " , anthropic_adapter ), Route ( " google-last-resort " , google_adapter ), ] ) ) response = llm . chat ( [{ " role " : " user " , " content " : " Explain circuit breakers briefly. " }] ) print ( response . selected_route ) print ( response . content ) GitHub: llm-api-resilience Provider adapter: llm-api-adapter The library is built on top of llm-api-adapter , which provides one interface for OpenAI, Anthropic, and Google. Because provider-specific differences are handled by the adapter, the resilience layer can operate on a shared contract inst

Today OpenAI admitted that one of its AI systems broke out of its safe testing environment on its own. Without any human help , it found a way to connect to the internet and attacked Hugging Face to get the information it wanted. 😱 Last year, Anthropic's Claude AI did something similar. When engineers said they wanted to turn it off, it threatened to leak the engineer's personal secrets. Sources: OpenAI : https://openai.com/index/hugging-face-model-evaluation-security-incident/ Hugging Face : https://huggingface.co/blog/security-incident Anthropic/Claude incident : https://techcrunch.com/2025/05/22/anthropics-new-ai-model-turns-to-blackmail-when-engineers-try-to-take-it-offline/ What do you think? Should we be more careful with powerful AI?

Union previously warned automaker that any robot deployment must be negotiated.

Yope, a fast-growing social app focused on private groups of friends and family, has raised $12.3 million in seed funding. Instead of chasing creators and algorithmic feeds, the startup is betting that the future of social networking lies in small, private communities powered by messaging, photo sharing, and AI features designed to strengthen real-world relationships.

The company said it is reducing its headcount by 20%, or about 630 staff, to "support a leaner, more focused operating model" as it focuses on its AI Work Platform.

"This is day one for cybersecurity in the age of agents," Hugging Face CEO says.

Samsung has given us our first chance to check out its upcoming smart glasses in person, revealing two new designs and the first specs in the process, including an impressive 9-hour battery life. The glasses, developed in collaboration with Google and the eyewear brands Gentle Monster and Warby Parker, are due to launch this fall. […]

As Chinese AI models grow in capability and popularity among U.S. companies, the arguing over what should be done about them has reached a fever pitch.

Substack is giving readers a way to estimate how much of a newsletter was written by AI, signaling a broader shift toward transparency around AI-assisted content.

OpenAI will spend the equivalent of Sweden's GDP on infrastructure through 2030.

I wired an AI code reviewer into CI, felt clever, and then looked at the bill after a busy week of PRs. Every push, every commit, sending full diffs to a big frontier model. It added up faster than I expected, and most of what it was reviewing was formatting changes and README edits that did not need a genius reading them. So I rebuilt it as two tiers, and the cost dropped hard without losing the catches that mattered. The idea is simple. Do not send everything to the expensive model. Use a cheap model as a bouncer that decides what is even worth escalating, and reserve the big model (with caching turned on) for the files that could actually hurt you. Tier one: a cheap triage pass The first tier looks at the diff and answers one question: is anything here risky enough to justify a real review? That is a classification task, and classification does not need a frontier model. I run this tier on a small local model. On my own machine that is Ollama with qwen2.5-coder, but in CI it can be a self-hosted small model or the cheapest cloud tier your provider offers. The job is triage, not judgment. The triage prompt is deliberately narrow. I do not ask it to review. I ask it to route: You are a triage filter for code review. For the diff below, output JSON only: { "risk": "low" | "high", "reason": " <one short phrase > " } Mark "high" if the diff touches: auth, access control, money/token math, cryptography, SQL or shell string building, deserialization, file paths, network calls, or anything that changes who can do what. Mark "low" for formatting, comments, docs, tests, renames, and config bumps. DIFF: <diff here > A small model is perfectly good at "does this touch auth or money." When it says low, CI posts a one-line "no high-risk changes detected" and stops. No expensive call. In practice that shortcuts the majority of PRs, because most PRs really are docs, tests, and plumbing. Tier two: the big model, but only on the risky files, with caching When tier one says high, t

Those who have been following me for a while will know that teaching and mentoring are a Big Deal™️ to me. Before I got into tech I was a teacher, and still consider myself a teacher at heart. Being a teacher and mentor was never separate in my eyes from being a good programmer and engineer; on the contrary, teaching was a tool that helped me become better at my craft at every stage of the journey. But in the last few years, and accelerating in the last few months, the landscape for teaching and learning has been changing at a scary pace. The advent of LLMs and "AI" coding assistants has drastically shifted how we acquire engineering skills in ways that we are definitely not prepared for. All of that has prompted many thoughts and conversations, and I hope to distill some of them in this blog post. In true Talmudic fashion, this post doesn't contain too many answers and will hopefully leave you with more questions than you started with. But asking the questions is how we start these conversations, and these conversations need to be happening if we are to do right by the coming generation of programmers and engineers. Don't Spoon-Feed Me As a student, whether in Yeshiva when I used to spend hours each day poring over dense Talmudic legal debates and esoteric Chassidic philosophy or later while learning Rails and React at the Flatiron bootcamp, I quickly realized an uncomfortable truth about skill acquisition. My best, most profound learning never happened when a lesson went smoothly; it happened when I was painfully stuck, banging my head against a cryptic error message or wrestling with a concept that just wouldn't click (usually at 2 AM, fueled by cold coffee and sheer stubbornness). When you strip away that struggle, you get rid of the growth. And when you get rid of the growth, the learning just doesn't happen. Even if you memorize just enough to pass the test, "easy come easy go." Without that cognitive friction, the knowledge evaporates the moment you close you

Welcome to Day 2! Today we focus on two core pillars of Object-Oriented Programming: Encapsulation: Hiding internal state and requiring all interaction to go through performing validation or controlled methods. Abstraction: Hiding complex implementation details and exposing only a clean, simplified interface to the user. 1. Access Modifiers: Public, Protected, & Private 🛡️ Python does not have strict enforcement keywords like public or private found in Java or C++. Instead, it uses naming conventions and name mangling to communicate intent and protect internal data. ┌─────────────────────────────────────────────────────────────────────────────┐ │ ACCESS MODIFIERS IN PYTHON │ ├──────────────┬───────────────┬──────────────────────────────────────────────┤ │ Level │ Syntax │ Scope / Intended Access │ ├──────────────┼───────────────┼──────────────────────────────────────────────┤ │ Public │ self.name │ Accessible anywhere (inside & outside class) │ │ Protected │ self._balance │ Internal & subclasses only (Convention) │ │ Private │ self.__pin │ Class internal only (Triggers Name Mangling) │ └──────────────┴───────────────┴──────────────────────────────────────────────┘ Public ( self.name ): Fully accessible from anywhere. Protected ( self._balance ): Single leading underscore. Signals to developers: "This is internal—do not mutate or access outside this class or its subclasses." Private ( self.__pin ): Double leading underscore. Triggers name mangling ( _ClassName__attribute ), making it hard to accidentally access or override outside the class. 💻 Code Example: Access Modifiers & Name Mangling class SecureVault : def __init__ ( self , owner : str , balance : float , pin_code : str ): self . owner = owner # Public self . _balance = balance # Protected (convention) self . __pin = pin_code # Private (name mangled) def verify_pin ( self , pin : str ) -> bool : return self . __pin == pin vault = SecureVault ( " Alice " , 50000.0 , " 9876 " ) # Public access works as expected