An article from ACM Queue for developers, focused on Design, Architecture and practical engineering…
发布日期：2026-03-30 · 来源：ACM Queue
Published: 2026-03-30 · Source: ACM Queue
设计Design架构Architecture
An article from ACM Queue for developers, focused on Architecture and practical engineering takeawa…
发布日期：2026-04-02 · 来源：ACM Queue
Published: 2026-04-02 · Source: ACM Queue
架构Architecture
作者介绍了一个免费浏览器工具站的部署过程，涵盖从多种工具组合到最终落地在 Cloudflare Pages 的实践。
Small Helper Tools is a free, browser-based utility site — wheel spinners, dice rollers, finance calculators, text utilities, developer…Continue reading on Medium »
发布日期：2026-04-05 · 来源：Medium Web Development
Published: 2026-04-05 · Source: Medium Web Development
随笔随笔
文章强调，很多设计师每周都会浪费大量时间在手动调整间距上，而 Auto Layout 能系统性地解决这个问题。
Most designers waste 3+ hours every week on manual spacing adjustments. Here’s how to stop.Continue reading on Medium »
发布日期：2026-04-04 · 来源：Medium UI Design
Published: 2026-04-04 · Source: Medium UI Design
设计Design随笔随笔
作者从此前的控制台程序过渡到 GUI，介绍 Java 中图形界面开发的基础概念。
So far, most of the Java programs I have created were console-based, where input and output happen through the terminal.Continue reading on Medium »
发布日期：2026-04-05 · 来源：Medium Programming
Published: 2026-04-05 · Source: Medium Programming
随笔随笔
文章深入讨论前端缓存、cache busting，以及为什么“只是部署一下”在真实系统里远远没有那么简单。
A deep dive into frontend caching, cache busting, and why “just deploy” is never really just a deploy.Continue reading on Medium »
发布日期：2026-04-04 · 来源：Medium Frontend
Published: 2026-04-04 · Source: Medium Frontend
前端Frontend随笔随笔
文章认为，很多 AI harness 工作聚焦在执行层，例如上下文管理、工具访问、验证和子 agent 协同，但真正缺失的是“把架构约束也纳入 harness”。作者提出 pattern registry、deterministic architecture compiler 和 workflow rules，来把团队架构约束变成可执行的控制边界。
Originally published in longer form on Substack. This DEV version is adapted for software engineers and platform practitioners who want the practical takeaway quickly. Most AI harness work focuses on execution. That makes sense. Teams need better context management, tool access, workflow boundaries, verification, memory, and sub-agent coordination. Without those pieces, coding agents are unreliable fast. But there is a different failure mode that those harness improvements do not solve: an agent can operate inside a well-designed execution harness and still produce the wrong architecture. That is the missing layer. The Real Problem Is Not Just Code Quality Ask an agent to design a small SaaS product and it will often produce something that is technically coherent and operationally excessive at the same time. You get things like: microservices where a monolith would do Kubernetes where managed PaaS is the obvious fit heavyweight observability and rollout machinery for a team with no real platform capacity provider choices that quietly add lock-in or operational burden reliability mechanisms sized for a much larger organization None of that is necessarily irrational. It is just architecture optimized for an imaginary team. That is what happens when the harness governs what the agent can see and do, but not what kinds of systems it is allowed to design. What the Harness Usually Misses Most organizations already have architectural constraints, whether they write them down well or not: cost ceilings preferred cloud/saas providers approved deployment models auth and identity boundaries operational limits compliance expectations explicit exclusions The problem is that these often live in: docs ADRs wiki pages tribal memory architecture review meetings That is not enough for agent-driven workflows. If those constraints are not machine-readable and enforceable, the agent is still reasoning inside an underconstrained design space. What I Mean by "Architecture Inside the Harness" The core idea is simple: The harness should not only manage execution. It should also constrain architecture. In practice, that means three pieces: 1. A pattern registry Architectural knowledge has to live somewhere reusable. A pattern in the registry can encode: what constraints it supports what NFR thresholds it can satisfy what it provides and requires what config decisions it exposes what cost and adoption trade-offs it carries That turns architecture knowledge from conversation into versioned policy. 2. A deterministic architecture compiler The compiler takes a canonical spec and selects patterns based on explicit rules. The key property is determinism. Given the same inputs, it should produce the same outputs. That gives teams something they can actually review and approve. It also makes architectural change visible as a diff instead of as implementation drift discovered too late. 3. Workflow rules around the compiler The compiler alone is not enough. You also need workflow discipline that tells the agent: when to compile when planning has surfaced a real architecture change when re-approval is required when implementation is allowed to proceed That is what turns architecture from documentation into a control point. Why Determinism Matters At the architecture layer, the problem is not mainly creativity. It is governance. That is why deterministic behavior matters more than people often expect. It gives you: reproducibility auditability explicit assumptions explicit exclusions a recompile-and-diff path when constraints change For senior engineers and platform teams, that is much more useful than a model producing a plausible design summary in slightly different words each time. A Concrete Example I used this approach in a Bird ID application workflow. The product itself was simple: users upload bird photos, an AI model identifies likely species, and results are stored in per-user history. The important part was not the feature list. It was the operating context: hosted PaaS backend managed Postgres OIDC for auth object storage for uploads low traffic strong cost sensitivity no real ops team Once those became compiler inputs, the architecture was constrained mechanically rather than conversationally. That made it much easier to reject patterns that would have been technically valid but wrong for the project: heavyweight deployment patterns overly complex topology choices infrastructure layers that added operational cost without real payoff The downstream effect mattered too. The approved architecture could then be handed to planning and implementation as an explicit contract instead of a loose design memo. The Real Deliverable Is Not Better Documentation The main output of this style of harnessing is not prettier architecture docs. The real output is an enforceable boundary between architecture and implementation. That boundary matters because implementation agents are good at creating drift quickly. If the architecture says: OAuth2/OIDC with PKCE hosted PaaS managed Postgres monolithic service topology then implementation should not quietly reintroduce: server-side session state new provider choices new persistence layers unnecessary distributed complexity Without a hard boundary, those changes show up as "implementation details." In practice, they are architecture changes. What Platform Teams Should Take From This If you are building internal agent workflows, the practical lesson is: do not stop at context engineering. Context engineering improves what the agent can see. Tool engineering improves what the agent can do. But neither is enough to keep the system architecture aligned with actual team constraints. Platform teams need something stronger: explicit architecture inputs deterministic architecture selection approval and re-approval boundaries implementation workflows that are forced to stay inside the contract That is what architecture inside the harness gives you. Closing The value of a harness is not only that it makes agents more capable. The value is that it bounds the solution space so capability is applied in the right direction. If the architecture layer stays implicit, fast agents will simply accelerate architectural drift. If the architecture layer becomes explicit, reviewable, and enforceable, then agent speed becomes much easier to trust. That is the argument: architecture is the missing layer in AI harness engineering. Links Longer Substack version: https://inetgas.substack.com/p/ai-harness-engineering-at-the-architecture Architecture Compiler: https://github.com/inetgas/arch-compiler Bird ID case study: https://github.com/inetgas/arch-compiler-ai-harness-in-action
发布日期：2026-04-04 · 来源：DEV Community
Published: 2026-04-04 · Source: DEV Community
后端BackendDevOpsDevOps架构ArchitectureDXDX设计Design
作者指出，LLM 常把基于代码可验证的结论和对外围系统的猜测混写在同一段流畅表述里，导致评审者必须自己拆分“文件里真的支持了什么”和“模型只是合理猜了什么”。文章用 VDG protocol 作为一种让模型显式暴露未知与假设的方式。
Blended inference is the baseline response mode of LLMs. Smooth prose is the goal. In software, that smoothness can hide the boundary between grounded analysis and inferred assumptions. The generation process does not distinguish between a token the model can support and one it filled in. Everything comes out at the same confidence level. I ran a small experiment on a Python caching service by asking: We’re seeing latency spikes on our report generation API. What should we look at? The baseline response correctly identified concrete areas to improve in the file: no lock or request coalescing on cache miss, a cleanup job that scans all of Redis, a stale flag that never gets checked, and synchronized TTL expiry. In the same answer, at the same confidence level, it also said things like: “If this runs periodically on the same Redis used by the API, it is a strong candidate for periodic spikes.” “If many hot reports are created around the same time—after deploy, after nightly prefetch, after business-hour traffic ramps up—they can expire around the same time too.” “Correlate p95/p99 latency with cache hit rate for /reports/generate.” None of those lines are absurd. Some may even be useful. The model did not know my Redis topology. It did not know my traffic shape. It did not know whether I had that telemetry. It did not verify the correlation it recommended. It moved from what it could support from the file to assumptions about the surrounding system and wrote both in the same voice. Instead, the burden of sifting grounded analysis out of a flood of smooth prose falls on me. That changed what review required from me. I could not just ask whether a sentence was wrong. I had to decompose the answer: what came directly from the file, what followed from reasoning over the file, and what entered because the model filled in missing context. I then reran the same prompt and the same code using VDG protocol. The concrete analysis stayed. But the response could no longer glide past what it did not know. Instead of silently leaning on unknowns, the response had to put those unknowns in the Gap section: “No request metrics were provided, so it is unknown whether spikes are dominated by aggregate_transactions runtime, Redis latency, or concurrent duplicate work.” “No Redis topology was provided. It is unknown whether this cache is dedicated or shared, how many total keys live in db=0, and whether Redis CPU or memory pressure is present.” “No traffic-shape data was provided. It is unknown whether a small set of hot report keys dominates traffic or whether demand is evenly distributed.” “No client retry behavior was provided. It is unknown whether callers retry generate aggressively on slow responses, which would magnify stampedes.” I could see what the file supported, what the model inferred, and what remained open. That is the value of VDG protocol. Not just a consistent response shape, but a way to force the model to take on the burden of separating grounded analysis from inferred assumptions.
发布日期：2026-04-05 · 来源：DEV Community
Published: 2026-04-05 · Source: DEV Community
后端Backend性能PerformanceAIAI