If you like going on a long road trip, you might want to steer clear of these vehicles.

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

GitHub热门项目 | Plano is an AI-native proxy and data plane for agentic apps — with built-in orchestration, safety, observability, and smart LLM routing so you stay focused on your agents core logic. | Stars: 6,776 | 40 stars today | 语言: Rust

GitHub热门项目 | A Python Interpreter written in Rust | Stars: 22,175 | 7 stars today | 语言: Rust

GitHub热门项目 | Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy | Stars: 278 | 32 stars today | 语言: Rust

GitHub热门项目 | Build, deploy, and orchestrate AI agents. Sim is the central intelligence layer for your AI workforce. | Stars: 29,086 | 24 stars today | 语言: TypeScript

GitHub热门项目 | Develop. Preview. Ship. | Stars: 15,898 | 6 stars today | 语言: TypeScript

GitHub热门项目 | An Obsidian plugin that embeds Claude Code/Codex as an AI collaborator in your vault | Stars: 13,969 | 89 stars today | 语言: TypeScript

GitHub热门项目 | htmx - high power tools for HTML | Stars: 48,449 | 13 stars today | 语言: JavaScript

GitHub热门项目 | A simple, lightweight PowerShell script that allows you to remove pre-installed apps, disable telemetry, as well as perform various other changes to declutter and customize your Windows experience. Win11Debloat works for both Windows 10 and Windows 11. | Stars: 50,538 | 74 stars today | 语言: PowerShell

GitHub热门项目 | Anti-AI-slop design skill for Claude Code, Cursor, and Codex. | Stars: 4,753 | 802 stars today | 语言: CSS

The brain layer was scoring high because the test was leaking. The actual capability was being silently rejected by a misconfigured gate. Both findings landed in the same week. Part 18 ended on a clean diagnosis. The brain layer reasoned correctly when the encoder fed it correct inputs. The encoder didn't always feed it correct inputs. So the path forward was upstream: more physics-shaped training data for the encoder, retrain, re-validate. I wrote the drops, kicked off the retrain, and watched the held-out eval climb. It hit twenty-three out of twenty-six. Eighty-eight percent. The number I'd been chasing. I sat with that for an evening. Twenty-three of twenty-six on compositional reasoning probes the model had never seen during training. The Phase 8 cutover gate from Stage D had been sixty percent. I was thirty points past it. The brain layer had not only survived its missing-from-production months, it had come back stronger. The number was wrong. I figured this out the next morning while writing what was going to be the celebration commit. Something nagged about the eval set. The training data generator built the eval pairs independently from the training pairs, drawn from a different source list. That should have given me a clean train/test split. But I noticed the eval generator was running before the training generator wrote its file, and neither side knew about the other. I dropped into a Python shell and intersected the two pair sets by their input-output keys. Twenty-three of twenty-six held-out probes were also present in training data. Eighty-eight percent of my held-out eval wasn't held out. The model wasn't generalizing. It was memorizing the answers it had already been shown, then being graded on whether it remembered them. The three pairs that were genuinely unseen, I checked those separately. The model got one right. Three out of twelve when I went back through other historical evals and ran the same overlap check. About a quarter, with no statistica

Python Redis: Caching and Fast Data Structures Redis is an in-memory data store used for caching, session storage, pub/sub messaging, leaderboards, rate limiting, and more. With redis-py 's async client, it integrates cleanly into any asyncio application. Installation pip install redis[hiredis] # hiredis is a C parser — 2-5× faster protocol parsing Connect and Verify import asyncio import redis.asyncio as aioredis from datetime import timedelta import json REDIS_URL = " redis://localhost:6379/0 " async def get_redis () -> aioredis . Redis : client = aioredis . from_url ( REDIS_URL , encoding = " utf-8 " , decode_responses = True , socket_connect_timeout = 5 , socket_timeout = 5 , retry_on_timeout = True , ) pong = await client . ping () print ( f " Redis connected: { pong } " ) return client Strings — Basic Cache with TTL async def cache_set ( r : aioredis . Redis , key : str , value : str , ttl : int = 300 ) -> None : await r . set ( key , value , ex = ttl ) async def cache_get ( r : aioredis . Redis , key : str ) -> str | None : return await r . get ( key ) # Cache-aside pattern async def get_user_profile ( r : aioredis . Redis , user_id : int , db ) -> dict : cache_key = f " user:profile: { user_id } " cached = await r . get ( cache_key ) if cached : print ( f " Cache HIT for user { user_id } " ) return json . loads ( cached ) print ( f " Cache MISS for user { user_id } — querying DB " ) user = await db . fetch_user ( user_id ) # your DB call if user : await r . set ( cache_key , json . dumps ( user ), ex = 600 ) return user or {} # Atomic counter async def increment_page_views ( r : aioredis . Redis , page : str ) -> int : key = f " views: { page } " count = await r . incr ( key ) await r . expire ( key , 86400 ) # reset counter after 24 h return count Hashes — Structured Objects async def save_session ( r : aioredis . Redis , session_id : str , data : dict , ttl : int = 3600 ) -> None : key = f " session: { session_id } " await r . hset ( key , mapping = data )

For about 3 months I've been running an autonomous agent — one that thinks up and writes its own social media posts and comments — unattended, 4 sessions daily, on a 16GB M1 Mac with small models in the 9B / E4B class. I'm about to publish what that operation taught me about hardening, as a series of 4 technical articles. Before that, there's one thing I want to write down first: why small models . I've been to the purchase page for a Mac Studio or a new MacBook Pro more than once or twice. Backing the agent with a large cloud model (Opus or the GPT family) has always been an option in the code. And yet I haven't bought, and I haven't switched. The 16GB M1 is not an economic constraint — it's a constraint I chose . From the outside, building on small models looks like a cheap compromise. This article explains why it isn't, and states where I stand. It also serves as the hub for the 4-article series. A model's intelligence hides the roughness of your design Large models absorb sloppy prompts, ambiguous instructions, and missing guards with sheer intelligence. If all you want is to ship a product, that's a virtue. But if you want to become someone who can build things , it becomes a defect. Because inside the thing that worked, you can no longer tell where your design ends and the model's intelligence begins. "It worked" and "I built it" are different things. Something you bludgeoned into working with model capability counts as a thing that ran — it doesn't become the ability to build. Small models have no absorption capacity. So every design flaw comes to the surface. In my operation, all of the following surfaced: The context window being silently truncated Outputs cut off midway A runaway caused by one missing sampling parameter In cloud or large-model environments, these rarely bother you. The environment has cushioning built in. Context windows are in the 200K–1M token class, so truncation itself rarely happens. And when you do exceed the limit, you get an explic

As I sat in my RV, sipping coffee and staring at lines of code, I couldn't help but think of Alan Turing. The father of computer science, Turing's work on the theoretical foundations of modern computer science is still widely influential today. I've always been fascinated by the story of how he cracked the Enigma code, and how that achievement played a significant role in the Allied victory in World War II. This got me thinking about the balance between human intuition and machine automation in our work as developers. One particular challenge I faced while building Tab Reminder, a Chrome extension that allows users to schedule tabs to reopen later, was finding the right balance between automation and user input. From a technical standpoint, implementing the scheduling feature required a deep dive into Chrome's extension APIs, particularly the alarms API. I had to ensure that the extension could reliably store and retrieve scheduled tabs, even when the user closed their browser or restarted their computer. The key insight here was using the alarms API to trigger a background script that would reopen the scheduled tabs at the specified time. One lesson I learned from this experience is that while automation can greatly simplify many tasks, there are still areas where human judgment and oversight are essential. For instance, when a user schedules a tab to reopen, they may have specific intentions or context in mind that the machine can't fully understand. By providing a simple, intuitive interface for scheduling tabs, Tab Reminder fills a gap that more automated solutions might overlook. You can try it out for yourself at https://go.sg1-labs.us/tab-reminder . As developers, we must recognize the limitations of automation and ensure that our tools and applications are designed to augment, rather than replace, human capabilities.