yceffort
20 POSTS

Page 1

  • #web-performance#debugging#blogging

    Which Element Caused This Blog's CLS

    Two causes found through the shifted elements recorded alongside CLS values: a decorative element that follows the cursor and was counted as a layout shift, and a home page list that pushed the footer down while the overall p75 stayed at 0.000. Both were confirmed with field data and lab reproductions.

    20 min read
  • ◆ Page Preservation in Next.js Part 2
    #nextjs#memory#web-performance

    Why Did Next.js's Last Three Leave Nine Posts Behind?

    Next.js is said to preserve the last three pages, yet nine posts remained on this blog. A sequential navigation experiment measures how far preservation reaches, then looks at managing memory by separating work to stop when hidden from state worth keeping.

    16 min read
  • #career#ai#essay

    Thirty Days of Working by Prompt: How Attention Disappears

    I counted 30 days of my own records, and there was no day when I stayed on one thing for 60 minutes

    18 min read
  • #code-review#software-engineering#essay

    Code Review Is Hard. For People, and for AI Too

    Code review is still hard

    23 min read
  • #react#debugging#nextjs

    Why Does the Body of a Static Page Wrapped in Suspense End Up in a Hidden div?

    Since React 19.2, content wrapped in Suspense can be moved into a hidden element even on a static page whose render has already finished. I traced how the post bodies on this blog shipped that way from May to early November, using the React source, version-by-version reproductions, and the HTML left in the Wayback Machine.

    20 min read
  • ◆ Improving number-flow Part 4
    #web-performance#animation#debugging

    How Far Will Agents Fix number-flow?

    I compared number-flow as fixed by five coding agents against my fork v0.2.1 once more. Performance reports changed with the font, the code went through a review with the authors hidden, and a follow-up experiment ended with keeping the mask default.

    Updated 31 min read
  • ◆ Improving number-flow Part 3
    #web-performance#browser#debugging

    Reducing Forced Synchronous Layout in the number-flow Update Path

    Every time the value of number-flow changed, style and layout were being recalculated several times over. This post records the performance change observed after 0.2.1 reordered how the library reads and writes the DOM, and the costs that remain.

    Updated 26 min read
  • ◆ Swapping the Model Behind a Coding Agent Part 4
    #ai

    Wrapping Up the Coding Agent Model Swap Experiment

    Looking back on 1,164 runs and the process of building an internal benchmark. Cost per task, the Claude Code run environment, what I had hoped for from open-weight models, and the conditions I would change next time

    7 min read
  • ◆ Swapping the Model Behind a Coding Agent Part 3
    #ai

    What Happens When You Swap the Model in Claude Code for GLM 5.3

    I solved 36 internal tasks three times each with Claude Sonnet 5.5 and GLM 5.3. Comparing resolved rate, limit stops, cost, and patch defects across 216 runs, looking at how the conditions differ from public benchmarks, and deciding whether to swap the model

    Updated 32 min read
  • ◆ Swapping the Model Behind a Coding Agent Part 2
    #ai#testing

    Building 36 SWE-bench Tasks from 20 Internal PRs

    Turning merged PRs from an internal WebSocket package into coding-agent evaluation tasks, validating the grader, and isolating personal instructions from the Claude Code run environment

    Updated 22 min read
  • #web-performance#software-engineering#essay

    In Performance Work, the Techniques Were Short and the Judgment Was Long: Preparation, Observation, Response, Verification, Measurement

    What should come before choosing a performance technique? This post follows the order used in practice: settling the support range and dependencies, measuring, deciding priorities, responding when the cause lives in someone else's code or infrastructure, guarding against regressions, and reporting results.

    35 min read
  • ◆ Core Web Vitals 직접 수집하기 Part 4
    #web-performance#devops#debugging

    Self-Hosting Core Web Vitals Collection for a Quiet Blog

    Moved a Core Web Vitals collection setup designed for shared observability infrastructure to my personal blog. Fixed a dashboard left empty by sparse traffic and changed when metrics are collected for ordinary browsers. Along the way I found why some query results went missing, and worked out how much five days of data can support.

    32 min read
  • ◆ Core Web Vitals 직접 수집하기 Part 3
    #web-performance#devops#debugging

    Sending the Core Web Vitals of an App Webview to a Shared Observability Platform

    Sent the Core Web Vitals measured in an app webview to an observability platform shared by many teams. The webview gave no signal on leaving, and tail sampling, delta-to-cumulative conversion and Tempo queries each dropped values in their own way without raising an error. For every setting that could not be changed, re-measured what was lost in a reproduction environment.

    Updated 37 min read
  • ◆ Core Web Vitals 직접 수집하기 Part 2
    #web-performance#debugging#browser

    Sending Core Web Vitals at the Moment of Leaving the Page

    Traced why CLS and INP go missing when the page is left, through the transport of OTel JS and the order in which flush runs.

    Updated 22 min read
  • ◆ Core Web Vitals 직접 수집하기 Part 1
    #web-performance#debugging#browser

    When Does web-vitals Report Core Web Vitals

    Checked the conditions under which web-vitals 6.2.3 reports each metric, and why INP goes missing when the page is left right after a click.

    Updated 33 min read
  • ◆ Swapping the Model Behind a Coding Agent Part 1
    #ai

    How to Compare the Models Behind a Coding Agent with SWE-bench

    How do you measure the model performance of a coding agent?

    Updated 28 min read
  • ◆ Building coldpath Part 4
    #bundler#debugging#compiler

    How Bundlers Remember Imports

    Tracing a coldpath misclassification that read every synchronous dependency in the Turbopack analysis file as a static import. This post compares the graph information and build output of webpack, Turbopack, Vite, and esbuild, and looks at which clues reveal the original syntax and which cases cannot be recovered.

    29 min read
  • ◆ Improving number-flow Part 2
    #web-performance#animation#browser

    Improving number-flow Performance: Moving Animations onto the Compositor Thread

    In the number-flow fork I built to support old browsers, animations in modern browsers were still recalculating styles on every frame. In 0.2.0 I moved the motion built with additive compositing into transform and opacity keyframes, but costs remain in the mask and in interruptions.

    Updated 24 min read
  • #pwa#caching#service-worker

    Saving Marp Slides from a Next.js App for Offline Use

    I built offline saving into a Marp slide viewer. This post follows the process from the first attempt to run the existing viewer offline as-is to fixing, one at a time, the problems that deploys, networks, and the presenter window exposed.

    Updated 23 min read
  • ◆ Page Preservation in Next.js Part 1
    #nextjs#react#debugging

    Pages You Leave Don't Die, They Hide: Next.js cacheComponents and React Activity

    Next.js 16's cacheComponents hides the pages you leave with React Activity instead of unmounting them. Following a three.js canvas that went blank after a back navigation, I read the router, React, and react-three-fiber source and reproduced it in a browser.

    34 min read