I tested GitHub Copilot Workspace on 12 real tasks across three repositories in May 2026 — a mix of bug fixes, feature additions, and documentation updates. My goal was to figure out whether the spec-first, browser-based workflow actually produces useful code, or whether it is a demo that falls apart when you ask it to do real work. The answer sits somewhere between impressive and frustrating, with the tool's success rate varying dramatically based on task size, repository maturity, and how well you write the initial specification. The Spec-First Workflow Forces Better Communication Copilot Workspace changes the AI coding interaction in one fundamental way that I have not seen elsewhere: you do not start with code, you start with a specification. When I opened Workspace on a Next.js project and typed "add rate limiting to the API routes using the existing rate-limit.ts utility," the system did not immediately generate code. It spent roughly 15 seconds reading my repository, then produced a three-step implementation plan: (1) import the rate-limit utility in each route, (2) wrap the route handler with the rate limiter, (3) add a test for the rate-limited behavior. I could approve the plan as-is, reject individual steps, or add revision notes before any code was written. On this particular task, the plan was correct and I approved it. Workspace then executed each step, modified five route files, and produced a draft pull request with a clear description and a summary of what changed. The entire process — from typing the specification to having a reviewable PR — took 4 minutes and 12 seconds. This planning phase is not window dressing. On a different task where I asked Workspace to "add WebSocket support to the chat feature," it read the repository and surfaced during planning that the project was deployed on Vercel's serverless functions, which do not support persistent WebSocket connections. It suggested using Vercel's Edge Functions with a third-party real-time serv

I've been running AI workloads on Azure Container Apps for over a year. Every time I spin up a new agent backend, the ritual is the same: create an environment, configure networking, set scaling rules, wire up health probes, then deploy the actual container. For a prototype agent that might live for a week, that's too much ceremony for what you get. ACA Express, which hit public preview in May 2026, kills most of that ceremony. And a separate but related announcement, Docker Compose for Agents, brings MCP gateways and model serving to standard ACA environments. They solve different problems and run on different infrastructure, but together they cover the full spectrum of agent deployment on Azure. Let me break down both. ACA Express: What It Actually Is Express is a new environment tier within Azure Container Apps. You bring a container image. Express handles provisioning, HTTPS, scaling (including scale-from-zero with subsecond cold starts), and resource allocation. No environment to manually provision through the portal. No networking to configure. No scaling rules to write. Under the hood, Express is built on ACA Sandboxes, a platform primitive that uses prewarmed pools to deliver that subsecond startup. This isn't the standard ACA cold-start experience with a fresh coat of paint. It's a different architecture. The tradeoffs are real. Express is HTTP workloads only, consumption CPU only. No GPU. No VNet integration. No Dapr. No service discovery between apps. No managed identity at runtime. No health probes. If you need any of those, standard ACA environments are still there. But for stateless HTTP agent backends, Express is dramatically faster to deploy and cheaper to run. Here's what it takes to get a container running: # Create an express environment az containerapp env create \ --name my-express-env \ --resource-group rg-my-agents \ --environment-mode express \ --logs-destination none # Deploy your app az containerapp create \ --name my-agent-api \ --resource

🚀 The Golden Age of “Just Ship It” A few months ago, I started building side projects differently. Instead of: Planning architecture Reading documentation Writing every function manually I started doing this: “Build me a responsive dashboard with authentication, dark mode, PostgreSQL integration, and Stripe payments.” And somehow… It worked. AI tools can now generate: APIs UI components Database schemas Docker configs Tests Documentation We’ve entered the era of vibe coding . And honestly? It feels amazing. What Is “Vibe Coding”? Vibe coding is when you: Describe what you want Let AI generate most of the implementation Keep iterating through prompts Instead of engineering every detail manually, you steer the vibe of the application. Tools making this popular: Cursor GitHub Copilot Claude Windsurf ChatGPT Replit AI You become less of a code writer and more of a: reviewer editor product thinker debugger At least in theory. The First Few Days Feel Like Magic The productivity boost is unreal. You can build in hours what used to take days. Things that once required: Stack Overflow endless documentation tabs debugging sessions at 2 AM …now happen through prompts. You feel unstoppable. Then Production Arrives And production is where the vibes end. Because production doesn’t care if the demo looked cool. Production cares about: edge cases reliability security scalability maintainability observability This is where AI-generated code starts exposing cracks. Problem #1: The Code Looks Right This is the dangerous part. AI code is often: clean formatted nicely modern-looking confident But hidden underneath: unnecessary complexity duplicated logic subtle bugs bad abstractions Problem #2: Hallucinated Architecture AI is very good at generating: components snippets isolated features It is much worse at: long-term architecture consistency scaling systems over time You start noticing: 4 different API patterns duplicated utilities random folder structures inconsistent state management

If you've trained a transformer in the last three years, your GPU spent most of its wall-clock time inside a matrix multiplication. The kernels doing that work were probably written by cuBLAS, generated by a compiler stack like Triton, or hand-assembled on top of NVIDIA's CUTLASS templates. CUTLASS is the one most people don't see directly, but it sits underneath a surprising amount of modern AI infrastructure — from FlashAttention to vLLM to several internal kernels inside PyTorch. What CUTLASS actually is CUTLASS — CUDA Templates for Linear Algebra Subroutines — is a header-only C++ template library NVIDIA publishes on GitHub under Apache 2.0. It is not a drop-in replacement for cuBLAS. cuBLAS gives you a closed-source binary with a stable API: you call cublasGemmEx and you get a tuned kernel. CUTLASS gives you the building blocks to write your own kernel, with control over tile sizes, data layouts, epilogues, and how the kernel decomposes work across the GPU's memory hierarchy. That control is the point. If you're building a custom inference engine and your projection layer needs to fuse a GEMM with a SiLU activation and a residual add, cuBLAS can't fuse the epilogue for you — you'd launch the GEMM, then a separate elementwise kernel, paying twice for global memory traffic. With CUTLASS, the epilogue is a template parameter. You write the fusion once, instantiate the template, and the compiler emits a single kernel. This is why CUTLASS shows up wherever standard cuBLAS shapes don't fit — unusual data types like FP8, custom epilogues, sparse or grouped GEMMs, attention-shaped matrix products. Anywhere the stock library doesn't have what someone needs and the performance ceiling matters, you tend to find a CUTLASS kernel. CUTLASS is not a productivity library. It is a kernel-author's library. If you're writing PyTorch model code, you'll never import cutlass directly — you'll consume kernels that were built on top of it. The audience here is people who write the ker

I am responsible for a research project that is supposed to train a GPT-like model (Transformer-decoder) with 100M, 250M and 500M model variants. # params ## training dataset - 750M tokens - vocabulary is ~15k to ~100k tokens (depends on tokenizer settings) - ~3% of the vocabulary is used in ~50% of the training tokens (similar to language, where most of the vocabulary is used very sparsely) ## training hyper-params - optimizer = AdamW - lr = 1e-3 (works the best compared to 1e-2 and 1e-4) - betas = [0.9, 0.95] - effective batch size = 4M tokens - epoch = 16 - warmup steps ~200 (approx 1 epoch) ## model hyper-params - 16 layers (but variants with up to 48 layers were tested) - embedding = flexible to yield 100M, 250M and 500M model - MLP size = 4*n_embd - 16 attention heads - context window = 1000 # Issue The model seems to fail to learn the basic auto-regressive behavior. It often gets stuck on generating a single token (no repetition penalty, no sampling yet). Is training GPT-like models still a black magic? Is there some trick to this? *Disclaimer*: I will add/edit the parameters above as people ask clarifying questions. submitted by /u/gartin336 [link] [留言]

The advice was correct. That's what makes it interesting. A creator with a large audience recently described the problem precisely: unused project ideas atrophy. They gave the prescription: externalize the idea, commit to a 30-60-90 day sprint, get into a community that holds you accountable, treat a deployed URL as the only real milestone. The audience listened. The ideas stayed unshipped. Not because the advice was wrong. Because advice is not a mechanism. The gap between diagnosis and structure There's a category of knowledge that's completely useless without enforcement. "You should exercise consistently." Correct. Also irrelevant for the 80% of people paying for gym memberships they don't use. "You should ship your side project in 30 days instead of perfecting it." Also correct. Developers have been hearing this for years. The projects that were "almost done" last year are still almost done. The advice identifies the problem. The problem persists. The gap between them is not information. It's structure. Discipline is the tax on misalignment One phrase from the transcript stayed with me: "Discipline is the tax on misalignment." The insight is sharper than it sounds. When what you're building doesn't connect to why you're building it, every work session requires a new act of will. You're not building forward momentum — you're paying an interest payment on a debt you haven't quite defined. This is why most sprint systems fail. They give you the structure (30 days, daily tasks, accountability partner) but skip the alignment check. The structure holds for two weeks. Then it becomes another system you're "almost following." What the AI makes worse Here's where it gets specific for developers using AI tools on side projects. The AI is genuinely useful. It generates architectures, writes boilerplate, outlines features, summarizes where you are. The output looks like forward motion. But the AI has no ground truth about your actual progress. It has your files and your pr

Introduction In my previous IAM article we learnt basics of IAM and how to create Users, Groups and attach Policies. You can refer here: https://dev.to/kadhamvj23/aws-identity-and-access-management-explained-for-beginners-cn7 After setting up secure access to our AWS account using IAM, the next question we mostly have is where do we actually run our application? The answer is Amazon EC2 - Elastic Cloud Compute. EC2 is one of the most widely used AWS services and understanding it well is essential for anyone starting their cloud journey. In this article we will cover what EC2 is, why it exists, the different types of instances, pricing models, Regions and availability Zones and finally hands-on walk through of creating your first EC2 instance. Breaking Down the Name -EC2 Let us understand what each word in the name actually means: Elastic --> In AWS you will notice many services have this prefix "Elastic". The reason is simple. Whenever AWS provides a service that can be scaled up or scaled down based on our needs, that service is called Elastic . With EC2 you can increase resources when traffic is high and decrease them when the traffic is low. So in simple terms EC2 = A virtual server on the cloud that you can resize anytime. Cloud: EC2 runs on AWS's public cloud infrastructure, meaning the servers are owned and managed by Amazon across the world. Compute: The word compute means you are asking AWS to provide you CPU, RAM and Disk - basically a virtual machine or server that can run your applications. How does EC2 actually work? When you request a Virtual server from AWS, here is what happens behind the scenes: You request a virtual machine on AWS ⬇️ request goes to a Hypervisor(a software layer sitting on top of physical servers that creates and manages VMs) ⬇️ Hypervisor creates your VM ⬇️ You get the access to your EC2 instance You never touch any physical hardware. AWS manages all of that for you. Why use EC2? Imagine your company wants to host an application. T

Why We Built JaisCloud — A Free, Single-Binary AWS Emulator in Go If you've ever tried to test AWS-dependent code locally, you've probably reached for LocalStack. It works — but it comes with baggage: Python runtime, Docker dependency, and the features most teams actually need locked behind a Pro subscription. JaisCloud is our answer to that problem. What is JaisCloud? JaisCloud is a free, open-source local AWS cloud emulator written entirely in Go. It implements the exact AWS wire protocols — Query/XML, JSON/Target, REST — so your existing SDK code points at JaisCloud and works unmodified. No shims, no proxy rewrites, no SDK patches. # Start it jaiscloud-aws start # Point your SDK at it export AWS_ENDPOINT_URL = http://localhost:4566 export AWS_ACCESS_KEY_ID = test export AWS_SECRET_ACCESS_KEY = test export AWS_REGION = us-east-1 # Your existing code works — no changes needed aws s3 mb s3://my-bucket aws sqs create-queue --queue-name my-queue The Problem With Existing Solutions JaisCloud LocalStack Community Moto Single static binary Yes No - Python + Docker No - Python library Zero runtime deps Yes No No Postgres persistence Yes Pro only No Real Spark/EMR execution Yes No No Apache Iceberg Yes No No Prometheus metrics Yes Pro only No State export / import Yes No No Deterministic time control Yes No No Written in Go Yes No No License Apache-2.0 Apache-2.0 Apache-2.0 Key Features Single Static Binary JaisCloud ships as a single Go binary per cloud. No Python, no Docker, no Node — just download and run. Works on laptop, CI runner, or Kubernetes pod. # Download and run — that is it ./jaiscloud-aws start # Or with Docker docker run --rm -p 4566:4566 rjaisval/jaiscloud-aws:latest Portable State Snapshots Export the complete emulator state — every resource, every account, every region to a single gzip tarball and restore it anywhere in milliseconds. # Capture a baseline jaiscloud-aws export -o baseline.tar.gz # Restore on a teammate's machine or CI runner jaiscloud-aws i

I switched my primary editor to Cursor in January of 2026 after spending three years on VS Code with GitHub Copilot. The reason was not the chatbot sidebar — every editor has one of those now — but the tab completion model that felt qualitatively different the first time I used it. After six months of daily use across TypeScript, Python, and Go projects, I have a clear picture of what Cursor actually changes about the coding experience and where the marketing outpaces the product. The Tab Completion Model Changed How I Write Code The first thing I noticed with Cursor was that I was pressing Tab instead of thinking about what to type next. That sounds minor, but after tracking my usage over a two-week comparison period, I found that Cursor's tab model correctly predicted my next edit 73 times out of 100 attempts in TypeScript files — measured by counting how often I accepted the ghost text suggestion versus how often I ignored it and typed manually. The mechanism behind this is Cursor's speculative continuation engine. It does not wait for you to stop typing before offering a suggestion. As you modify a function signature at the top of a file, the model silently recalculates the impact on every call site below. I tested this explicitly on a 340-line TypeScript service file where I renamed a parameter from userId to accountId . Before I could scroll to line 180 where the first call site appeared, Cursor had already ghost-written the updated argument. By the time I reached line 310, all six call sites had correct suggestions waiting. That multi-location awareness is what I have not seen any other editor replicate consistently. Not every language gets the same treatment. I ran the same completion acceptance test across three languages I work in regularly. TypeScript came in at the 73 percent acceptance rate I mentioned. Python was close behind at 68 percent. Go was noticeably worse at 51 percent, and the Go suggestions that I did accept frequently required minor correct

Article URL: https://www.ycombinator.com/companies/ramain/jobs/hqvmyKN-founding-gtm-engineer Comments URL: https://news.ycombinator.com/item?id=48303599 Points: 0 # Comments: 0

A database of 125K+ angels and VCs to raise your seed round Discussion | Link

After finishing the app I've been working on, I decided to use Paddle to handle monthly and yearly subscriptions. I followed their documentation and getting started page and did almost everything they say, yet I got this error as in the screenshot. That happens after I generate a checkout link in the server side, and navigating to it. If you've encountered such issue before and somehow fixed it, or at least you know a little better in this field, any helpful hints or advices will be truly appreciated https://preview.redd.it/1y9muysics3h1.png?width=1209&format=png&auto=webp&s=baebc208c65540d0a2cc8be24c0e90110b3ceefd submitted by /u/WadieZN [link] [留言]

Blog post: https://wezteoh.github.io/posts/diffusion-for-sketch-guided-trajectory-simulation/ During NBA games, coaches often sketch attacking plays on a whiteboard and mentally simulate how teammates and defenders might react. In this project, I explored using diffusion models for controllable basketball trajectory simulation. Instead of only forecasting future trajectories, the model generates gameplay conditioned on partial “sketches” of player movement instructions. One interesting aspect is that diffusion models refine all player trajectories jointly, which makes sketch-conditioned simulation feel more natural compared to autoregressive generation. I wrote up the methodology, experiments, and implementation details in the link above. Code and model are fully open sourced as well. Curious to hear thoughts from others working on generative modeling, trajectory prediction, or sports analytics. submitted by /u/part-time-delver [link] [留言]

GitHub热门项目 | agent multiplexer that lives in your terminal. | Stars: 2,639 | 853 stars this week | 语言: Rust