<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kris Wong on Medium]]></title>
        <description><![CDATA[Stories by Kris Wong on Medium]]></description>
        <link>https://medium.com/@kris.wong?source=rss-12a6ea0e1302------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*f2T8PmOmICJqZg5f1RngbA.jpeg</url>
            <title>Stories by Kris Wong on Medium</title>
            <link>https://medium.com/@kris.wong?source=rss-12a6ea0e1302------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:40:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kris.wong/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your AI Agents Don’t Know What Your Senior Engineers Know]]></title>
            <link>https://levelup.gitconnected.com/your-ai-agents-dont-know-what-your-senior-engineers-know-9c576809e2c4?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c576809e2c4</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Fri, 02 Oct 2026 14:47:15 GMT</pubDate>
            <atom:updated>2026-10-02T14:47:15.069Z</atom:updated>
            <content:encoded><![CDATA[<h4>How I use instructions, automated checks, and shared context to make engineering knowledge available beyond a single conversation.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ggh58Bhpo_QomjrOi-eqiQ.png" /></figure><h4>The different roles of instructions, automated checks, CI, and shared context in AI-native development</h4><p>In <a href="https://levelup.gitconnected.com/the-ai-engineering-factory-capability-throughput-and-value-9d90dd7b1585">my previous post</a>, I wrote about the engineering system around the model: the specifications, context, tools, verification, and feedback loops that turn model capability into useful production software. I want to go a little deeper on one part of that system, because it accounts for a meaningful amount of the work involved in making agents effective.</p><p>An experienced engineer knows a lot about a codebase that the codebase does not explain. They know why a particular abstraction exists, which implementation is being retired, which seemingly reasonable approach caused problems before, and who is already working on something related. When they review a change, all of that context influences their judgment. They may spot a problem immediately without realizing how much background knowledge made it obvious.</p><p>An agent does not automatically have any of that. It has the instructions we provide, the code and documentation it reads, and the information it can retrieve through its tools. If something important exists only in my head, I cannot reasonably expect the agent to account for it.</p><p>That sounds obvious, but it changes how I think about corrections. When I tell an agent that it chose the wrong approach, part of the question is whether it had a reasonable way to know what the right approach was. And if I have made the same correction several times, I need to look at why the system keeps requiring me to supply it.</p><p>At <a href="https://www.closedloop.ai/">Closedloop</a>, this has led me to think about several layers of engineering knowledge and feedback: tribal knowledge, prose instructions, local deterministic checks, CI, and the knowledge graph available through Closedloop Intel. They overlap, but each contributes something different to the agent’s ability to do useful work.</p><h4>The knowledge has to be available before it can help</h4><p>Tribal knowledge is useful to the people who possess it. Until someone expresses it or makes it retrievable, it is effectively useless to an agent.</p><p>Our monorepo has a good example in the distinction between the design system and shared product UI. We have a generic component library in packages/design-system, and we have shared Closedloop components in packages/app. Both contain reusable UI. The distinction is that the design system is a separate, project-agnostic product, while the shared application package is allowed to understand our domain: sessions, branches, documents, projects, and the rest of the product.</p><p>If you have worked in the repository for a while, that boundary is familiar. If you are an agent asked to build a reusable component, “put it in the design system” is a plausible interpretation of the task. It may even look like good engineering. You are reusing code, avoiding duplication, and putting a component in the package whose name suggests that it owns components.</p><p>The missing information is why this particular component does not belong there.</p><p>This is where prose earns its place. Repository instructions can explain the boundary, the reason for it, and the correct home for the implementation. The agent can use that information while deciding how to approach the task, before it spends time building something we will have to move later.</p><p>I use prose at several different levels. Persistent repository instructions carry broadly applicable constraints. Skills describe procedures for particular types of work. Implementation plans capture the decisions and acceptance criteria for a change. Prompts supply the immediate request and any additional context that matters to it.</p><p>Those distinctions are useful because the information has different lifetimes. The ownership boundary between two packages may remain relevant for years. A decision about what to include in the first release of a feature belongs with that feature. A debugging procedure should be available when an agent is investigating a bug, without occupying every unrelated conversation.</p><p>The objective is to give the agent enough context to do the right thing on the first attempt. Clear prose can prevent a substantial amount of wasted work, especially when it explains a decision the agent could not confidently infer from the implementation alone.</p><p>It is also possible to overdo it. A repository instruction file can become an accumulation of every mistake an agent has ever made, complete with exceptions, repeated warnings, and rules that were written for circumstances that no longer exist. Maintaining those instructions is part of the work. More text does not necessarily produce more understanding.</p><h4>The first attempt will still be wrong sometimes</h4><p><a href="https://claude.com/blog/the-ai-native-sdlc-playbook">Anthropic’s AI-native SDLC playbook</a> uses a useful term for skills: <em>advisory controls</em>. They guide the agent toward applying a policy, but the instructions themselves do not enforce compliance. That describes the role of much of the prose around an agent. It can improve the decision without guaranteeing the result.</p><p>Even when the instructions are clear, agents will miss things. They will choose the wrong import, misunderstand a contract, or make a change that breaks an existing behavior. Some of these failures are predictable enough that we should not need a human to discover them repeatedly.</p><p>Hooks and deterministic checks give the agent feedback while it is working. Linting, typechecking, unit tests, and repository-specific gates can identify a problem before the change reaches review. Some hooks can intervene earlier still, blocking an action before it occurs — for example, an attempted edit to a protected generated file. Others run after an edit and give the agent information it can use to repair the implementation.</p><p>The design-system boundary has both forms of support. We explain it in prose, and we have a source gate that detects imports from prohibited domain packages. The instructions help the agent understand where the component belongs. The check catches a concrete violation if the implementation crosses that boundary anyway.</p><p>There is a limit to what that gate can establish. A component could contain Closedloop-specific assumptions without importing one of the prohibited packages. Recognizing that still requires judgment. But the import violation is a mechanical problem, and making a reviewer repeatedly catch it is a poor use of review attention.</p><p>I think this distinction matters when deciding what to automate. Some engineering expectations are difficult to express as reliable checks. Others are straightforward, but remain review comments because nobody has invested in making them executable. In an agent-heavy workflow, that investment becomes more valuable because the same class of mistake can appear across many independent sessions.</p><p>The quality of the diagnostic matters too. A failure that identifies the violated contract and explains where the code belongs gives the agent a reasonable path forward. A vague failure leaves it investigating the validation machinery before it can return to the actual task.</p><p>We also have to pay attention to what the agent changes while making a check pass. If it repairs the implementation by weakening the assertion, removing a difficult case, or changing the expected behavior, the green result may no longer tell us what we think it does. Tests sometimes need to change, but those changes deserve review against the requirement they were supposed to protect. Otherwise, the implementation and its verification can drift together.</p><p>The existence of a check does not establish its quality. A unit test can faithfully verify the wrong assumption. A source gate can cover only part of a rule. Typechecking cannot decide whether the feature solves the customer’s problem. These tools provide specific evidence, and I still need to understand what that evidence covers.</p><h4>CI broadens the feedback</h4><p>Local feedback needs to be fast enough that the agent can use it repeatedly. That creates practical limits on how much we run during every implementation cycle.</p><p>A formatter or a check scoped to the changed file can run frequently without interrupting the work very much. A full integration suite is a different proposition. Running it after every edit would consume time without necessarily producing useful new information. Waiting until the end to run every check creates the opposite problem: the agent may build several more changes on top of a mistake before discovering it.</p><p>Where we place validation determines both how quickly the agent can recover and how much work accumulates before recovery begins.</p><p>CI gives us another opportunity to perform more expensive checks, exercise broader dependencies, and evaluate the change in a controlled environment. In a monorepo, the scope difference is particularly important. A package can pass its own tests while breaking a consumer. Shared UI can behave correctly through one surface adapter and incorrectly through another. A focused test run may never exercise the boundary where the failure occurs.</p><p>Our repository has affected-package checks, broader verification commands, and separate validation lanes for different parts of the system. Shared product UI also needs consideration on both web and desktop, because sharing the component does not mean the routing, data access, or surrounding behavior is identical.</p><p>This gives the agent several opportunities to encounter useful feedback. It can catch an inexpensive mistake while editing, discover a behavioral regression in a focused test, and then encounter an integration failure in a broader run. Each opportunity should cover something meaningful at a cost appropriate to that point in the work.</p><p>As implementation gets faster, those costs become more visible. Verification runtime and coverage are part of the development system’s throughput, just as much as the time the agent spends writing code.</p><h4>The agent also needs to understand the surrounding work</h4><p>Instructions and executable checks address a lot of implementation mistakes, but they do not provide a complete view of what is happening around the task.</p><p>An agent can build a technically sound solution to work that someone else is already doing. It can make a reasonable local change without knowing that another project is replacing the underlying contract. It can read an implementation without finding the product decision that explains why it behaves that way.</p><p>This is where the knowledge graph available through Closedloop Intel fits into the workflow. It gives agents access to relationships between tickets, plans, code, branches, and pull requests. They can investigate scope overlap, follow the lineage of a work item, and look for dependencies or other work touching the same area.</p><p>That information helps the agent form a better picture of the problem before deciding what to do.</p><p>Suppose I ask an agent to add a capability to an existing feature. Code exploration can tell it what is implemented today and which abstractions are available. Ticket and dependency information can reveal that part of the request is already in progress, that another issue establishes a prerequisite, or that the work originated in a larger plan with constraints that are not obvious from the code.</p><p>Without that context, the agent may produce a coherent implementation that creates unnecessary reconciliation work for the team. Access to the surrounding work gives it a chance to recognize those relationships earlier.</p><p>The graph needs the same scrutiny as other information sources. Coverage and freshness matter. A recorded relationship is evidence to investigate, and claims about the current code still need to be checked against the relevant checkout. But this is a much more useful starting point than expecting every agent to reconstruct organizational context from whatever happens to be mentioned in its prompt.</p><p>It also reduces the amount of information I need to manually package for every task. I can give the agent a focused request and a way to discover relevant context, rather than trying to anticipate and paste everything it might need.</p><h4>The environment needs evaluation too</h4><p>There is another implication of putting more engineering knowledge into the agent’s environment: changes to that environment can change the quality of its work.</p><p>We are accustomed to testing the code an agent produces. We should also evaluate whether a revised instruction, a new skill, or a different hook actually improves the agent’s ability to produce it. A skill can be well written and still fail to load when needed. A new instruction can resolve one recurring mistake while creating confusion elsewhere. A model change can alter how consistently the same configuration is followed.</p><p>The Anthropic playbook recommends keeping representative tasks and their acceptance checks as an evaluation suite, then using that suite when the agent configuration changes. That seems like a useful extension of the same discipline. We would be checking whether the agent can still perform real work to the expected standard, rather than assuming that adding more guidance improved the system.</p><p>I would want those evaluations grounded in the mistakes and tasks that matter to the team. Can the agent choose the correct package for a component? Does it run the relevant validation? Can it find an existing implementation instead of creating another one? Those are more useful questions than whether the instruction file appears comprehensive.</p><h4>Where the correction belongs</h4><p>The practical value of these layers is that they give me a better way to respond when an agent gets something wrong.</p><p>Sometimes the necessary information was never available. Sometimes it was documented, but the agent failed to follow it. Sometimes the implementation passed a narrow check while breaking something outside that check’s scope. Sometimes the code was fine, but the work duplicated or conflicted with something already underway.</p><p>Those are different failures, and they call for different improvements. Writing a longer prompt is not a particularly good response to all of them.</p><p>More of my work now involves deciding where engineering knowledge should live so that it remains useful beyond the current conversation. That may mean documenting an architectural decision, creating a better skill, adding a deterministic check, expanding a CI lane, or making related work discoverable through the graph.</p><p>None of this guarantees that the next agent will make the right decision. It gives the agent better information to work from and more useful ways to recognize and recover from mistakes.</p><p>If I keep making the same correction, I want to understand what keeps forcing that knowledge back through me. The next session should be able to benefit from what we already learned.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c576809e2c4" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/your-ai-agents-dont-know-what-your-senior-engineers-know-9c576809e2c4">Your AI Agents Don’t Know What Your Senior Engineers Know</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The AI Engineering Factory: Capability, Throughput, and Value]]></title>
            <link>https://levelup.gitconnected.com/the-ai-engineering-factory-capability-throughput-and-value-9d90dd7b1585?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d90dd7b1585</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-native-development]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Wed, 01 Jul 2026 17:08:20 GMT</pubDate>
            <atom:updated>2026-07-01T17:08:20.981Z</atom:updated>
            <content:encoded><![CDATA[<h4>AI Makes It Cheaper to Build the Wrong Thing, Too</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RL_129zZdGV6MVXZVVqQrA.png" /></figure><p>This post complements <a href="https://medium.com/gitconnected/i-ran-1-700-claude-code-sessions-and-ranked-in-the-top-1-of-engineers-0129155a0b3f">my previous post</a>. I recommend that you read it as well.</p><p>Every major model release changes what is possible with AI-assisted software development. Tasks that required frequent supervision six months ago can now run independently for much longer. Agents are getting better at navigating unfamiliar codebases, preserving intent across larger changes, diagnosing failures, using tools, and making reasonable implementation decisions without being told exactly what to do at every step.</p><p>I also continue to see meaningful differences between models. Claude and GPT have distinct strengths, weaknesses, working styles, and failure modes. I may prefer one for architectural exploration, another for focused implementation, and another to challenge an existing plan or investigate a difficult bug. These differences are significant enough that I do not believe models are interchangeable commodities, at least not today.</p><p>The model is the foundation of an AI-native engineering system. More capable models raise the ceiling for everything we build on top of them, and the productivity gains from those advances are real. But the model is only one part of the system required to produce valuable production software. A capable model working from an ambiguous request, inside a poorly prepared environment, with no meaningful way to verify its output, will still produce unreliable results.</p><p>After running thousands of Claude Code and Codex sessions, I have started to think about this in three layers:</p><blockquote>Capability creates potential. The factory creates throughput. Customers determine value.</blockquote><p>The model determines what is possible. The engineering system around it determines whether that capability can be applied repeatedly and safely. The customer determines whether any of that output was worth producing.</p><h4>The model establishes the ceiling</h4><p>It is tempting to attribute most of the gains from AI-assisted engineering to process: write clearer specifications, improve context, add tests, use isolated worktrees, and create stronger review loops. All of those practices matter, but they do not <em>fully</em> explain the jumps in productivity I have experienced between model generations.</p><p>A stronger model can understand more of the system at once and maintain coherence through a more complicated task. It can follow architectural constraints more consistently, use tools more effectively, recover from errors with less guidance, and recognize when its original plan no longer matches what it is discovering in the codebase.</p><p>Those improvements compound. A model that makes slightly better decisions at each step does not merely produce code that is slightly better. It requires fewer interventions, spends less time pursuing dead ends, and leaves behind less cleanup. The result is a larger class of work that can be delegated without continuous supervision.</p><p>This makes model selection a legitimate engineering decision. Cost, latency, reasoning depth, tool use, context handling, and the consequences of failure all matter. Different models may also be useful at different stages of the same workflow. One can develop an implementation plan while another critiques it. One can perform the work while another reviews the result from a fresh context.</p><p>Even an excellent model, however, does not define the entire development system. Capability establishes the ceiling. The surrounding environment determines how consistently the system operates near that ceiling.</p><h4>Building the factory around the model</h4><p><a href="https://www.kaggle.com/whitepaper-the-new-SDLC-with-vibe-coding">A recent Google paper</a> on the new software development lifecycle describes a shift toward a “factory model,” in which the developer’s output is increasingly not just code, but the system that produces code. <a href="https://code.claude.com/docs/en/best-practices">Anthropic’s Claude Code guidance</a> arrives at a similar conclusion from a more tactical direction, emphasizing persistent instructions, task-specific skills, executable verification, hooks, subagents, isolated environments, and independent review.</p><p>The factory includes the specifications that define intent, the context that explains the codebase and domain, the tools the agent can use, the environments in which it can execute safely, and the feedback mechanisms that tell it whether its work is correct. It also includes guardrails, observability, and the points at which human judgment is required.</p><p>At a previous employer, I worked on a problem that illustrates this distinction well. New customers needed to import a large amount of data before they could receive meaningful value from the product. The existing workflow accepted a file, processed it in the background, and eventually reported which records succeeded or failed.</p><p>Technically, the import worked. From the customer’s perspective, it was a frustrating onboarding experience. They could wait several minutes before discovering formatting problems, invalid values, or unexpected column mappings. A failure late in the process often meant editing the source file and starting over.</p><p>The obvious solution was to add an import preview and validation workflow. Customers would upload a file, see how the data would be interpreted, review validation failures, and understand what would happen before committing the import.</p><p>“Add an import preview” sounds like a clean task for a coding agent. It is also underspecified in nearly every way that matters.</p><p>Should validation happen in the browser or on the server? How large can a file be? Can preview data be returned to the browser, and how long should it be retained? What happens when two rows refer to the same existing record? Should a small number of invalid rows block the entire import? Can customers correct values inside the product, or must they edit the source file? Should preview validation and final import validation share the same domain logic?</p><p>A capable model can make plausible choices for all of these questions. The resulting feature may even be internally coherent. The problem is that those choices encode product behavior, security policy, operational constraints, and architectural consequences. They are not merely implementation details.</p><p>The task becomes safely delegable only after the meaningful decisions have been made. The team might decide that files should be uploaded directly to temporary object storage, validation should stream on the backend, and preview and import should use the same domain rules. It might decide that invalid rows block the first release because partial success creates reconciliation problems the product is not prepared to handle. It might intentionally exclude inline correction and instead produce a downloadable error report.</p><p>Once those boundaries exist, an agent can do substantial work. It can inspect the current pipeline, identify reusable validation logic, define a structured error format, implement the preview endpoint, build the interface, and add the surrounding tests. The factory has converted a broad product idea into executable work.</p><p>The objective is not to create a system in which the model never fails. No such system exists. The objective is to make failures visible, bounded, and recoverable before they become customer-facing problems.</p><h4>Context and verification determine autonomy</h4><p>For a while, much of the AI development conversation focused on prompt engineering. That framing now feels too narrow. The quality of the result depends less on finding an unusually clever phrase and more on giving the agent the information a strong engineer would need to do the work.</p><p>That information exists at several levels: persistent project rules, architectural decisions, domain-specific procedures, task-level requirements, existing patterns in the codebase, tool output gathered during execution, and decisions made earlier in the session. These different kinds of context have different lifetimes and should not all be placed in one enormous instruction file.</p><p>More context is not automatically better. Large rule files accumulate obsolete instructions. Generic guidance competes with task-specific requirements. The most important constraint may be present, but buried beneath thousands of tokens of unrelated material.</p><p>I have found it more useful to treat context as part of the architecture. Permanent instructions should contain rules that are broadly applicable, important, and not obvious from the code. Specialized procedures should live in skills that are loaded only when relevant. Product decisions and task-specific constraints belong in the implementation plan. Existing code should communicate the patterns the agent can discover by exploring the repository.</p><p>In the import example, the agent needs more than an instruction to build a preview screen. It needs to understand the customer problem, the current pipeline, the security model, the expected file sizes, the existing validation rules, and the product decisions around partial imports and correction workflows.</p><p>This is also why one of my most common prompts can be a single word: “Proceed.”</p><p>On its own, that would be a terrible specification. In my workflow, it usually follows a planning phase in which the agent has explored the codebase, written an implementation plan, received feedback, incorporated corrections, and been placed in an isolated worktree with explicit acceptance criteria. The final prompt is short because most of the work required to define the task has already happened.</p><p>A long prompt cannot compensate for unresolved product decisions. A short prompt can be sufficient when the surrounding context is complete.</p><p>The amount of autonomy I can safely give an agent also depends on the quality of the feedback it can receive without me. When an agent has no objective way to check its work, it has to decide when the result appears complete. Language models are very good at producing implementations that appear complete.</p><p>Executable feedback changes the workflow. An agent can implement a change, run a test, observe a failure, diagnose the cause, revise the implementation, and repeat the process. The feedback might come from unit tests, integration tests, typechecking, linting, browser automation, screenshots, API contract checks, performance thresholds, or deployment health.</p><p>For the import workflow, that means fixtures for malformed files, incorrect encodings, duplicate identifiers, unexpected columns, invalid values, and files large enough to exercise streaming behavior. It means browser tests for column mapping, error summaries, expired uploads, and recovery after a failed validation request. It also means security checks that verify one customer cannot access another customer’s file or validation result.</p><p>With those checks in place, the agent can do more than produce a first implementation. It can run the fixtures, observe failures, repair its work, and continue iterating without requiring a human to inspect every intermediate state. Better model capability improves the quality of each attempt. Verification allows the system to recover when an attempt is wrong.</p><p>This is also what makes concurrency useful. Once the architecture and contracts are settled, one agent can implement the streaming validation service, another can build the preview interface, and a third can add telemetry to the onboarding funnel. Starting them before those decisions are made would likely create three different interpretations of how validation should behave and shift the work from implementation into reconciliation.</p><p>The relevant question is not how many agents can run at once. It is how many genuinely independent lanes the system can support.</p><h4>AI makes it cheaper to build the wrong thing, too</h4><p>For most of software history, implementation cost acted as an imperfect form of prioritization. A meaningful feature required enough engineering time, coordination, and organizational commitment that teams had to make choices. Expensive ideas could still be bad, but the cost of producing software discouraged at least some low-value work.</p><p>AI lowers that cost dramatically. This is overwhelmingly positive. Teams can test hypotheses sooner, build prototypes faster, respond to customers more quickly, and explore ideas that would previously have been rejected because the implementation cost was too high.</p><p>Removing implementation friction also removes one of the constraints that forced product discipline. A team can now become extraordinarily efficient at building plausible features that customers do not need.</p><blockquote>AI makes it cheaper to build the wrong thing, too.</blockquote><p>In the import example, it would be easy to define success as shipping a preview and validation workflow. That is an output, not an outcome.</p><p>The actual hypothesis is that customers are failing or slowing down during onboarding because they cannot understand and correct their data before an import begins. If that hypothesis is correct, the new workflow should reduce repeated attempts, decrease time to a successful import, lower support demand, and increase the percentage of new customers who complete onboarding.</p><p>Those are the signals the team needs to measure. It should track the percentage of customers who complete an import, the average number of attempts required, the time between the first upload and the first successful import, the most common validation failures, and the relationship between import completion and later onboarding milestones.</p><p>Suppose the preview ships, works reliably, and reduces support tickets, but the onboarding completion rate barely changes. The implementation may be technically successful while the product hypothesis is only partially supported.</p><p>The team might discover that customers now understand why their files are invalid, but still do not know how to transform data from another system into the required format. The preview solved uncertainty after the upload. The more important customer problem begins before the file reaches the product.</p><p>That learning should influence what gets built next. The team might improve automatic column mapping, provide reusable templates, support inline corrections, or integrate directly with the systems customers are exporting from. It might also decide that the import experience is no longer the largest obstacle and redirect its attention elsewhere.</p><p>This is why faster delivery needs to be paired with stronger customer discovery, clearer problem definitions, explicit hypotheses, useful instrumentation, and a willingness to abandon work that does not create value. Increased engineering output does not reduce the need for product judgment. It raises the cost of weak judgment by allowing it to produce more software.</p><p>AI can dramatically shorten the cycle from hypothesis to working product, but the cycle creates value only when the team observes what happened and incorporates that learning into the next decision.</p><p>The goal is not simply to produce more software. It is to reduce the distance between a customer problem and a validated solution.</p><h4>Engineering work moves up the leverage stack</h4><p>I still spend time reading code, debugging failures, challenging abstractions, and making implementation decisions. AI has not removed the need for technical depth. It has changed where that depth produces the most leverage.</p><p>More of my time now goes toward defining the problem, making architectural boundaries explicit, preparing executable work, structuring context, creating verification loops, managing dependencies, and evaluating the result. These activities were always part of senior engineering work, but they become more central when implementation itself can be delegated at much greater scale.</p><p>This makes foundational engineering experience more valuable, not less. An inexperienced engineer may use AI to produce more implementation. An experienced engineer is more likely to recognize when a specification is incomplete, when an abstraction is drifting, when verification is superficial, or when a locally correct change is wrong for the broader system.</p><p>In the import example, the most important contribution may not be writing the parser or building the preview interface. It may be recognizing that preview validation cannot safely diverge from final import validation, that returning an entire customer dataset to the browser creates unnecessary risk, or that a technically elegant partial-import flow introduces an operational problem the organization is not ready to support.</p><p>The most important intervention is often not correcting generated code. It is recognizing that the agent is successfully solving the wrong problem.</p><p>AI reduces the cost of implementation, but it does not reduce the cost of poor judgment. In some cases, it dramatically increases the rate at which poor judgment compounds.</p><h4>Optimizing the entire path to value</h4><p>Better models matter because they expand the range, complexity, and quality of work that can be delegated. I expect future releases to continue producing noticeable increases in engineering productivity, just as recent releases have.</p><p>The factory matters because it turns that capability into repeatable throughput. Specifications, context, tools, isolated execution, tests, review, guardrails, and feedback loops allow a capable model to operate safely and consistently within a production environment.</p><p>Neither is the final objective. The purpose of a software product team is to identify meaningful customer problems, solve them, observe the results, and learn.</p><p>The highest-performing AI-native teams will not necessarily be the ones that generate the most code, run the most agents, or close the most tickets. They will be the teams that can identify valuable problems, translate them into clear intent, give capable models the environment to act, verify the resulting software, ship it safely, and measure whether it helped.</p><p>The opportunity is not merely to build software faster. It is to build a tighter and more reliable loop between customer needs, model capability, engineering judgment, and real-world outcomes.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d90dd7b1585" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/the-ai-engineering-factory-capability-throughput-and-value-9d90dd7b1585">The AI Engineering Factory: Capability, Throughput, and Value</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Ran 1,700 Claude Code Sessions and Ranked in the Top 1% of Engineers.]]></title>
            <link>https://levelup.gitconnected.com/i-ran-1-700-claude-code-sessions-and-ranked-in-the-top-1-of-engineers-0129155a0b3f?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/0129155a0b3f</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Wed, 24 Jun 2026 16:33:21 GMT</pubDate>
            <atom:updated>2026-06-24T16:33:21.844Z</atom:updated>
            <content:encoded><![CDATA[<h3>I Ran 1,700 Claude Code Sessions and Ranked in the Top 1% of Engineers. Here’s How My Work Has Evolved.</h3><h4>The bottleneck has moved</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xNp2A3Stb_ZSFAoUyK48ZQ.png" /></figure><p>For most of my career, software delivery had an obvious bottleneck: someone had to write the code.</p><p>That sounds too simple, but it shaped almost everything about how engineering teams worked. Planning mattered, design mattered, review mattered, CI mattered, but the limiting reagent was usually implementation. You could have a backlog full of good ideas, a clear product direction, and plenty of customer urgency, but none of it turned into software until an engineer sat down and pushed the code through.</p><p>AI-native development changes that in a very practical way. Not because the agents are magic. They are not. They make bad assumptions, miss context, overfit to the last instruction, and occasionally produce code that looks much better than it is. But they are fast enough, and useful enough, that implementation is no longer the only obvious constraint.</p><p>Once that happens, the bottleneck moves.</p><p>That has been the most important shift in my day-to-day work. The scarce resource is no longer “How quickly can I type and wire up this feature?” It is “How quickly can I prepare enough meaningful work for agents to execute?” and then “How quickly can I validate the work that comes back?”</p><p>Those are very different problems. They require different tooling, different habits, and a different mental model for what an engineer is doing all day.</p><p>Over the last month, my Claude Code logs make that shift pretty visible. Roughly speaking, I had more than 1,700 session files, around 1,500 subagent sessions, dozens of worktree paths, and a lot of activity spread across product work, plugin work, review work, CI, and cleanup. The exact numbers are less important than the shape of the work: the code was only one part of the system. A huge amount of the leverage came from preparing work, running multiple streams concurrently, and building validation machinery strong enough that I could trust the output.</p><p>That is what AI-native development looks like for me right now. It is not sitting next to one agent and watching it code. It is operating a system that is grounded in concurrency.</p><p><strong>Work Prep Became Real Engineering Work</strong></p><p>The first new bottleneck is upstream of coding: preparing work that is clear enough, bounded enough, and meaningful enough for an agent to execute.</p><p>This is easy to underestimate. If you hand an agent vague work, it will still produce something. That is part of the danger. It will fill gaps with plausible assumptions. It will pick a path. It will complete the shape of the request even when the important decisions were never actually made.</p><p>That means ambiguity does not disappear. It just moves downstream, where it becomes rework.</p><p>So I spend much more time now turning intent into executable work. At <a href="https://www.closedloop.ai/">Closedloop</a>, that often means generating PRDs, implementation plans, dependency notes, acceptance criteria, and explicit non-goals. That might sound like process overhead, but in an agent-heavy workflow it is closer to source code. It is the material the implementation system runs on.</p><p>A good work item is not just “build the branches page.” It says what the page is for, what is in scope, what is deferred, what existing patterns should be mirrored, what data is available now, what should gracefully degrade, which dependencies are hard build-order dependencies, which dependencies are soft, and what acceptance criteria define done.</p><p>That level of specificity matters because the agent does not share the full product context in my head. It only has the context I package for it, plus whatever it can recover from the codebase. If I want a good result, I need to make the work legible.</p><p>One recent example was a large <a href="https://www.closedloop.ai/">Closedloop</a> work stream around branch list and branch detail surfaces in our desktop app. The PRD decomposed into six sub-features covering shared data foundations, list-page work, detail-page routing, detail metrics, multi-actor timelines, and live GitHub overlays. Each feature had hard and soft dependencies, acceptance criteria, degradation behavior, and flagged upstream dependencies.</p><p>The important nuance is that I do not usually parallelize one work stream aggressively. Most real product work has dependencies. You cannot safely build the detail-page metrics before the data shape exists, and you cannot wire live overlays before the identity and gateway assumptions are settled. Pretending every project is arbitrarily parallelizable is a good way to create merge conflicts and conceptual drift.</p><p>The more common pattern is concurrency across work streams. That branches work stream was meaty, but it was also running alongside other work: plugin improvements, desktop cleanup, CI fixes, review follow-up, PR maintenance, and smaller product changes. Occasionally a single work stream can be split into parallel lanes, but only where the dependency graph allows it. The discipline is knowing the difference.</p><p>That is the upstream job now: find the boundaries. Slice the work where it is genuinely independent. Preserve sequence where it is not. Make the handoff precise enough that an agent can move without constantly asking what the work means.</p><p><strong>Concurrency Is The Multiplier</strong></p><p>The biggest productivity gains do not come from making one agent faster. They come from running more independent work without losing control.</p><p>This is where the workflow starts to look less like pair programming and more like operating a small engineering org. There are multiple worktrees. Multiple branches. Multiple PRs in different states. Some work is being implemented, some is being reviewed, some is waiting on CI, some is being cleaned up after merge, some is blocked on a product decision, and some is being decomposed into the next set of handoff-ready tasks.</p><p>That only works if the work is prepared well. Concurrency amplifies everything. If the work is clear, concurrency gives you leverage. If the work is vague, concurrency gives you a pile of inconsistent guesses.</p><p>The same is true for the codebase. Worktrees are essential because agents need isolated places to operate. Branch hygiene matters more, not less. PR boundaries matter more, not less. The more work happening at once, the more important it is that each lane has a clean purpose.</p><p>This is one of the places where I think people often misread AI-native development. They imagine the main skill is prompting a single agent really well. That matters, but it is not the whole game. The more interesting skill is throughput design: creating enough independent, well-specified lanes that agents can keep working while you are reviewing, planning, or unblocking something else.</p><p>The constraint becomes the serial part of the system. If agents can produce code faster than I can prepare work, preparation is the bottleneck. If they can produce code faster than I can review it, review is the bottleneck. If review is fast but tests take forever, validation runtime is the bottleneck.</p><p>The job is to keep finding the bottleneck and moving it.</p><p><strong>Generated Code Needs An Immune System</strong></p><p>The second major bottleneck is downstream: validation.</p><p>When I wrote most of the code myself, a lot of review happened implicitly. I had the context of the change because I made it. I knew which tradeoffs I took, which parts felt risky, which tests were thin, and which parts I wanted another engineer to look at closely.</p><p>When an agent writes the code, that implicit review disappears. I did not watch every line get written. I do not have the same tactile memory of the change. And if I am running multiple work streams at once, I might be reviewing a PR that came back while I was thinking about something else entirely.</p><p>That means validation has to become much more explicit.</p><p>This is where I have spent a lot of effort improving our <a href="https://github.com/closedloop-ai/claude-plugins">Claude Code review plugin</a> (which open source and available for free). The plugin started from a simple need: I wanted agents to help review code. But a useful review system cannot just be “ask Claude if this PR has bugs.” That produces too much noise, misses too much context, and creates a new review burden instead of reducing one.</p><p>The plugin has become more like a review pipeline.</p><p>It parses the diff. It runs deterministic hygiene checks. It partitions files. It routes higher-risk areas differently. It supports shallow, standard, and deep review modes. It has caching and incremental review, so unchanged work does not get reviewed from scratch every time. It has reviewer roles: bug hunters, domain critics, premise reviewers, coverage critics, impact analyzers. It has verifier passes that check whether a finding is real before it survives. It writes structured findings rather than freeform commentary. It can run locally or in GitHub mode. It can post inline comments, summarize results, and track prior review state.</p><p>The impact has been broad: it catches bugs I would have missed, reduces manual review time, lowers false positives through verification, makes larger PRs reviewable, improves PR hygiene, and makes me comfortable letting more agent-written code enter the system.</p><p>That last point is the most important. The plugin does not just improve code review. It increases trust bandwidth.</p><p>If implementation throughput goes up but trust bandwidth stays fixed, you do not get faster delivery. You get a queue of unreviewed diffs. The code-review plugin is one of the ways I keep validation from becoming the wall that everything crashes into.</p><p><strong>The Review System Has To Be Adversarial</strong></p><p>One lesson from building the plugin is that review agents need opposition built into the process.</p><p>A single reviewer agent is too easy to satisfy. It will often give you a plausible review-shaped answer. Sometimes it finds real issues. Sometimes it nitpicks. Sometimes it misses the thing that matters. The answer feels useful, but it is hard to know how much to trust it.</p><p>A better pattern is to split responsibilities. One agent looks for concrete bugs. Another looks at architectural fit. Another checks whether the premise of the change is sound. Another looks for missing test coverage. Another verifies whether the findings are actually grounded in the diff. Deterministic checks handle things that should not require model judgment at all.</p><p>This matters because generated findings have the same problem as generated code: they can be confidently wrong.</p><p>False positives are not harmless. They consume attention. They train people to ignore the review system. They slow down PRs. If an automated reviewer cries wolf often enough, engineers route around it.</p><p>That is why verifier passes matter. It is also why structured output matters. A useful finding needs a severity, a category, a file, a line, confidence, evidence, and a recommendation. It needs to be deduplicated. It needs to be scoped to the diff. It needs to survive basic checks before a human spends time on it.</p><p>The goal is not to remove human judgment. The goal is to make human judgment land on the highest-value part of the problem. I want to review the judgment, not reconstruct the entire investigation from scratch.</p><p><strong>Tests Still Matter More Than Ever</strong></p><p>One funny thing about AI coding tools is that they make old engineering fundamentals more important, not less.</p><p>Tests, typecheck, lint, CI, fixtures, schema validation, and reproducible review pipelines matter more when agents are producing code. They are the rails that let you increase concurrency without losing your mind.</p><p>My logs are full of validation work: test runs, lint runs, typechecks, CI polling, failing check triage, lockfile fixes, cleanup after merge. That is not incidental. That is the price of running wide.</p><p>I also found myself improving validation runtime itself. If tests are the bottleneck, then test concurrency becomes part of the AI-native workflow. Waiting on a serial test runner while multiple agents produce PRs is just moving the bottleneck to a different machine.</p><p>This is the same pattern again. Once implementation gets faster, every slow verification step becomes more visible.</p><p><strong>What I Actually Do Now</strong></p><p>The human role does not go away. It changes.</p><p>A lot of my work now is deciding what should happen, not manually performing every step. I scope. I sequence. I say no. I ask whether a change is warranted. I push back on shortcuts. I decide when a PR needs more validation and when coverage is not worth the time. I clean up after merges. I inspect failed checks. I turn vague intent into work an agent can execute.</p><p>Some of my prompts are terse because the surrounding system carries the context: “Proceed.” “Validate your changes, then open a PR.” “Rip it out.” “Use TDD here.” “The PR has conflicts.” “I added one more comment I would like addressed.”</p><p>That only works because there is structure around the agent. A terse instruction on top of a vague task is dangerous. A terse instruction on top of a well-scoped work item, in an isolated worktree, with CI and review machinery behind it, is a different thing.</p><p>That is the operating model I keep moving toward. Not one heroic prompt. Not one magical agent. A system of work preparation, execution lanes, review, validation, and human judgment.</p><p><strong>The Bottleneck Will Move Again</strong></p><p>I do not think the current bottlenecks are permanent. In fact they are already shifting.</p><p>As work preparation improves, more execution can happen in parallel. As review systems improve, more generated code can be trusted. As tests get faster, CI becomes less of a constraint. Then something else becomes the bottleneck.</p><p>Maybe it is product decision-making. Maybe it is human review attention. Maybe it is release coordination. Maybe it is the quality of the codebase’s internal boundaries. <a href="https://www.closedloop.ai/">Maybe it is the ability to observe what all these agents are doing without drowning in status updates</a>.</p><p>That is the mindset shift I would recommend to IC engineers experimenting with this stuff: do not ask only “How do I get the agent to write better code?” Ask “Where is the bottleneck now?”</p><p>If the bottleneck is unclear work, improve the handoff. If it is dependency management, improve the decomposition. If it is review, build better review machinery. If it is false positives, add verification. If it is CI, fix CI. If it is your own attention, reduce the amount of low-grade judgment you have to apply manually.</p><p>AI-native development is not just code generation. Code generation is the thing that exposes the rest of the system.</p><p>For me, the most valuable work has been building that system: <a href="https://www.closedloop.ai/">Closedloop</a> for making work explicit and handoff-ready, worktrees for isolated concurrent execution, and our <a href="https://github.com/closedloop-ai/claude-plugins">code-review plugin</a> for increasing trust bandwidth on the other side.</p><p>The code still matters. But writing it is no longer the center of gravity.</p><p>The center of gravity moved to the bottlenecks around it.</p><p>*Oh, and if you’re wondering about that “top 1% of engineers” title claim, it’s true, and I included it to make a point about the effectiveness of how I am working. Our team uses a product called <a href="https://pensero.ai/">Pensero</a> to measure our productivity. It measures our delivery against every user in their ecosystem. Over the past 30 days, I have consistently ranked in the 99th percentile, using the techniques I’ve described in this post.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0129155a0b3f" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/i-ran-1-700-claude-code-sessions-and-ranked-in-the-top-1-of-engineers-0129155a0b3f">I Ran 1,700 Claude Code Sessions and Ranked in the Top 1% of Engineers.</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Actually Use AI to Ship Production Software in 2026]]></title>
            <link>https://levelup.gitconnected.com/how-i-actually-use-ai-to-ship-production-software-in-2026-073349f24d00?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/073349f24d00</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Mon, 23 Mar 2026 16:14:03 GMT</pubDate>
            <atom:updated>2026-03-23T16:14:03.083Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fni1YfB3FKC3KWVlXDEdqQ.png" /></figure><p>The discourse around AI software development is stuck between two extremes: people shipping toy apps in a weekend, and people insisting these tools are useless in real codebases. My experience has been neither.</p><p>AI doesn’t replace software engineering judgment. It amplifies it best when you use a disciplined workflow built around context, planning, staged execution, and strong verification.</p><p>I’m a Staff Software Engineer with 23 years of experience, and this is the workflow I use to ship production software with AI in 2026. I will walk you through how I am leveraging AI tooling to deliver new features into production software products.</p><h3>My Setup</h3><p>Let me start with the AI tools I am using daily:</p><ul><li>Cursor — I use Cursor as my IDE, though I am not using any of the agentic features or the composer. I am only using tab completion.</li><li>Claude Code — This is my primary interface for AI-enabled work. Every developer on our team has the $200 max plan, and we use it extensively.</li><li>Claude Code plugins — I use several plugins from both the Anthropic official plugin marketplace, as well as our own suite of plugins available for free here: <a href="https://github.com/closedloop-ai/claude-plugins">https://github.com/closedloop-ai/claude-plugins</a>.</li><li>Codex — I mostly use Codex to review Claude’s work (more on this later), or when I have something that’s especially ambiguous or complex I’m working on. I have the $20 Pro plan, and it is sufficient.</li></ul><h3>My Process</h3><p>My process varies depending on the complexity of the task at hand, and also the context I am given for the body of work to be completed. This may or may not include a detailed PRD or Figma designs. Currently, I am working for a small startup on a new product that we have yet to release publicly. For this reason, time to market is critical, and we often favor quick iteration over detailed specification. That said, the more detailed the context you start with, the easier the implementation will be.</p><h4>Context</h4><p>When it comes to PRDs, we have two primary ways to create them. We can one-shot a PRD from a user-provided description of the feature to be built, along with our standard template. This works quite well and is great for moving fast. We also have an interactive <a href="https://github.com/closedloop-ai/claude-plugins/blob/main/plugins/code/skills/prd-creator/SKILL.md">PRD creator</a> that is better for situations where you have a concept that needs further refinement before it can be built. If a product manager does not provide a PRD when I am starting on a new feature, I may generate one myself if I believe it will help guide the agent toward a better implementation plan.</p><h4>Planning</h4><p>Once I know what needs to be built, I will formulate a loose plan for how the implementation process will go. If there is any technical investigation or feasibility that needs to be completed, I will start there. This includes tradeoff analysis, or selecting any new 3rd party frameworks or libraries that may be needed. I don’t have any hard and fast rules for choosing my tooling here. Over time, I’ve developed an intuition for which model is better suited to a given kind of problem. It is not unusual for me to use both GPT and Claude during this process, bouncing ideas back and forth. This is typically the most “manual” (least agentic) part of the process.</p><p>The next step is generating the implementation plans that will be used to generate the code for the feature I am working on. This will typically include one to three implementation plans. Any more than that, and you should probably decompose the work into smaller iterations. As an example, the first plan may detail database schema changes and data migration steps. A second plan may detail backend and REST API contract changes. Finally, the third plan may detail the frontend work to be completed. If there are several screens to be completed for a feature, I don’t deliver them all at once. I aim to deliver slices of independently verifiable user value.</p><p>To generate these implementation plans, I start with Claude Code. I may have a PRD or Figma designs to provide as context, or I may not. I’ll iterate on the plan with CC until I have something that I like. Then I’ll have Codex review the plan. It will almost always have feedback, which I then pipe into CC to address. After this process, I will have a solid plan that is ready for execution.</p><h4>Execution</h4><p>For any given implementation plan, I will review it and decide how many PRs I intend to open to deliver the full plan. This is based on the phases and tasks that are detailed in the plan. I rarely ask the agent to implement an entire plan at once. Instead, I scope work to a bounded set of tasks — often something like “implement tasks 1 through 4” — so I can review meaningful chunks of progress. Again, this is based on the language in the plan. I will then review the code and perform any necessary cleanup (sometimes manually, sometimes I tell CC to do it).</p><p>Once I am comfortable with the code, its organization, and that it delivers the intended functionality, I will run our automated code review command, and also a Codex code review, in parallel. I will then have CC verify and address the feedback provided. After this is complete, I am ready to open the PR. Our automated code review will run again in our CI process. Because the model is non-deterministic, it will frequently provide additional feedback. Other engineers on the team may provide feedback as well. I will address this feedback using CC.</p><h3>Parallelizing Work</h3><p>One of the many benefits of agentic software development is that we can easily parallelize work. I generally have one to two CC tabs open, as well as Codex, in my IDE. I use these for work I am doing “in the foreground”, if you will. This is generally the more complex work I have been assigned.</p><p>I also have a shell script that I can run from my terminal that will create and bootstrap a new git worktree, and launch CC ready to work using that worktree. The script does all the initialization steps and environment setup for our project. I can then have multiple efforts in progress simultaneously. This works well for tasks that need less guidance from me.</p><h3>Summary</h3><p>This post explains how I use AI tools to ship production software in 2026. Rather than “vibe coding,” my workflow is built around strong context, deliberate planning, staged execution, and repeated review. I primarily use Cursor for tab completion, Claude Code for implementation, and Codex as a second reviewer, often using multiple models to refine plans and challenge assumptions.</p><p>The core idea is that better input and strong verification lead to better output. I start with context, such as a PRD, Figma designs, or an AI-generated specification when needed. From there, I create one or more implementation plans, usually broken into small, independently verifiable slices of value across areas like database, backend, and frontend. Claude Code generates the initial plan, Codex critiques it, and I fold that feedback back in until the plan is strong enough to execute.</p><p>Execution is intentionally incremental. Instead of asking an agent to build everything at once, I assign bounded tasks, review the generated code, run automated and model-based code review, and use AI again to address feedback before opening a PR. I also highlight one of the biggest advantages of agentic development: parallelization. By using multiple Claude Code sessions and git worktrees, I can push several efforts forward at once, especially tasks that need less direct supervision.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=073349f24d00" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/how-i-actually-use-ai-to-ship-production-software-in-2026-073349f24d00">How I Actually Use AI to Ship Production Software in 2026</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I cut our Next.js first-load JS by 40% in under an hour]]></title>
            <link>https://levelup.gitconnected.com/i-cut-our-next-js-first-load-js-by-40-in-under-an-hour-b613dd780e8c?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/b613dd780e8c</guid>
            <category><![CDATA[optimization]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Sun, 30 Nov 2025 20:26:30 GMT</pubDate>
            <atom:updated>2025-11-30T20:26:30.678Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zTdi7GMV8Ag8Tcex8peX_g.png" /></figure><p>Recently I noticed that our “first load JS,” as reported by Next.js during our production build, had quietly grown to <em>over 1.3 MB</em>. Performance tuning isn’t a top priority for us right now (we’re still pre–product–market fit), but this felt like the kind of low-effort win that’s worth a quick look.</p><p>Turns out it was.</p><p>Here’s what our first load JS looked like before I touched anything:</p><pre>+ First Load JS shared by all                           1.31 MB<br>  ├ chunks/framework-322f45983bc5b2f0.js                57.5 kB<br>  ├ chunks/main-50495c26d623fd07.js                       37 kB<br>  ├ chunks/pages/_app-853396ef62613ac5.js                786 kB<br>  ├ css/fbc63c709d1e1499.css                             430 kB<br>  └ other shared chunks (total)                         2.66 kB</pre><p>The two obvious suspects were:</p><ul><li>the <strong>430 KB of CSS</strong></li><li>the <strong>800-ish KB _app chunk</strong></li></ul><h4>Chasing down the CSS bloat</h4><p>Opening the generated CSS file wasn’t helpful — it’s just a giant blob of flattened styles. But since this is a Next.js pages-router app (static export), I knew where CSS typically originates: <strong>_app.tsx</strong>.</p><p>Sure enough, we were importing a handful of CSS files:</p><ul><li>polyfills</li><li>a reset</li><li>Font Awesome styles</li><li>and <strong>four CSS files just for fonts</strong></li></ul><p>Those four font-related CSS bundles looked promising. When I checked them in Finder, they totaled <strong>over 500 KB</strong>. That’s basically the entire CSS payload.</p><p>Bingo.</p><p>We already shipped some fonts as .woff2, which is the efficient modern format. It turns out the fonts referenced through those CSS imports <em>also had .woff2 versions available</em> — we just weren’t using them.</p><p>All it took was:</p><ol><li>Copy the .woff2 files into /public/fonts</li><li>Add manual @font-face declarations in our own fonts.css:</li></ol><pre>@font-face {<br>  font-family: &quot;Inter&quot;;<br>  src: url(https://medium.com/&quot;/fonts/Inter-Regular.woff2&quot;) format(&quot;woff2&quot;);<br>  font-weight: 400;<br>  font-style: normal;<br>  font-display: swap;<br>}</pre><p>This let me delete <strong>all</strong> of the font-related CSS imports from _app.tsx — removing the huge generated CSS file entirely.</p><h4>The result</h4><pre>+ First Load JS shared by all                               818 kB<br>  ├ chunks/framework-322f45983bc5b2f0.js                   57.5 kB<br>  ├ chunks/main-50495c26d623fd07.js                          37 kB<br>  ├ chunks/pages/_app-69f11176b520d052.js                   712 kB<br>  └ other shared chunks (total)                            11.8 kB</pre><p>A ~40% reduction in first-load JS, just by fixing how fonts were shipped.</p><p>I also used the opportunity to remove a handful of unused assets we had accumulated over the last year.</p><h4>Running the Next.js Bundle Analyzer</h4><p>As a final sanity check, I ran Next’s bundle analyzer. This tool is incredibly helpful when you want a structural view of what’s actually inside your bundles. You can read about getting it setup <a href="https://nextjs.org/docs/app/guides/package-bundling">here</a>.</p><p>Here are the results for our main app JS file:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OdCYT20d5CLiaVElVctgAw.png" /></figure><p>Not surprisingly, the two biggest pieces of the file are foundational dependencies for our app: Tamagui and react-native-web. More surprisingly, the DataDog and PostHog SDKs were 3rd and 5th, respectively. We’re not using much of the API surface from these two SDKs, which tells me that they may not have enabled tree shaking.</p><p>This information could help you identify large bits of JS that could be lazy loaded via Next dynamic imports. It could also help you understand if certain 3rd party dependencies are worth keeping, or if you might want to find an alternative. Unfortunately for us, there is not a lot that is immediately actionable from this analysis, because we need all of these packages in our first load JS.</p><h4>Summary</h4><p>You could argue I “got lucky” — we were shipping fonts in an unnecessarily heavy way. But that’s exactly the point: <strong>organic growth tends to create easy wins</strong>.</p><p>Most apps that have been around for a year or more accumulate:</p><ul><li>dead assets</li><li>dead code</li><li>non-tree-shakable dependencies</li><li>and legacy imports that slip through the cracks</li></ul><p>Tree shaking can even hide these issues until you look at the generated output.</p><p>It’s worth spending an hour every so often doing a superficial audit. You might be surprised at how much performance you can buy back with very little engineering effort.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b613dd780e8c" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/i-cut-our-next-js-first-load-js-by-40-in-under-an-hour-b613dd780e8c">I cut our Next.js first-load JS by 40% in under an hour</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Nonce-Based CSP with AWS CloudFront]]></title>
            <link>https://levelup.gitconnected.com/nonce-based-csp-with-aws-cloudfront-ae5a6752b9b0?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae5a6752b9b0</guid>
            <category><![CDATA[single-page-applications]]></category>
            <category><![CDATA[security-header]]></category>
            <category><![CDATA[content-security-policy]]></category>
            <category><![CDATA[cloudfront]]></category>
            <category><![CDATA[lambda-edge]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Thu, 01 Jun 2023 13:38:08 GMT</pubDate>
            <atom:updated>2023-06-01T13:38:08.091Z</atom:updated>
            <content:encoded><![CDATA[<h4>Using a strict CSP with a CDN can be challenging</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IFFeVhuNVuH5VaG08RVZLw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@dtopkin1?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Dayne Topkin</a> on <a href="https://unsplash.com/photos/u5Zt-HoocrM?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><h4>Background</h4><p>Before we dive into the depths of strict Content Security Policy, let’s first briefly review the topic of <a href="https://cheatsheetseries.owasp.org/cheatsheets/HTTP_Headers_Cheat_Sheet.html">security headers</a>. Modern browsers support many different security headers that you can easily add to your website/web app. AWS CloudFront supports a number of these headers via Response headers policies, which you can easily associate with any behaviors you have. In fact, there’s even a managed policy named SecurityHeadersPolicy. The following is the policy we use at <a href="https://www.anthemiq.com/">AnthemIQ</a> for our index.html.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*rHkV1G_RnKk6ic1S6CZPCg.png" /></figure><p>You can verify the security headers sent by your site using <a href="https://securityheaders.com/">this nifty scanner</a>.</p><p>Now, when it comes to strict CSP, I recommend that you start <a href="https://csp.withgoogle.com/docs/index.html">here</a> to build a solid understanding of CSP and to see examples of a strict CSP. They also have a <a href="https://csp-evaluator.withgoogle.com/">CSP evaluator</a>.</p><h4>The Firefox Problem</h4><p>Assuming you have reviewed the site linked above, you now realize that there are two kinds of strict CSP with CSP 3. They are hash-based and nonce-based CSP. The nice thing about the hash-based CSP is that it doesn’t require injecting a random string into your index.html file every time it is served. And, in fact, <a href="https://izifortune.com/angular-subresource-integrity/">Angular can even generate script hashes for you when it builds your application</a>. You still need to get those hashes into the CSP header returned by your CDN, but that step gets a little easier vs. using a random nonce.</p><p><em>But… </em><a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1409200">Firefox does not support hash-based CSP</a>. Not only is it not supported, but since Firefox has partial CSP 3 support, it also doesn’t fall back to the insecure unsafe-inline either. Instead, it’s just completely broken. So, if you need Firefox support, then you only have one option — nonce-based CSP.</p><h4>CloudFront Functions and Lambda@Edge</h4><p>As a quick review, we know that CloudFront serves content from your configured <em>origins</em> via <em>behaviors</em>. I am assuming you are familiar with how this works. For many of us, we are serving static web content from S3 buckets. The problem boils down to serving this static content with a random string injected into it, which must change every time the content is served. Essentially, we are making our static content dynamic.</p><p>There are two primary mechanisms to do this — CloudFront functions and Lambde@Edge functions. I won’t dive into all the differences here, but suffice it to say that CloudFront functions are faster, while Lambda@Edge functions are much more capable. CloudFront functions don’t support what we need to do, so we’ll be using Lambda@Edge.</p><p>Lambda@Edge functions run a full Node.js environment, with network and disk support. The AWS SDK is included automatically, as it always is with Lambda functions. The main thing to note is that you must publish your function before you can use it with CloudFront. It does not support LATEST; you have to specify a version. That version of your function will be cached on various CloudFront nodes (hence the @Edge).</p><p>To complicate matters a little more, there are 4 different function associations that can be used:</p><ul><li>Viewer request</li><li>Viewer response</li><li>Origin request</li><li>Origin response</li></ul><p>Again, I won’t go into all the details here, but these options affect what gets cached and what properties on the request and response you have access to. The main points to understand are:</p><ul><li>none of these options give the function access to the response body returned from the origin, which means we are going to have to make a get-object request from our function to S3</li><li>because of this, we should prevent CloudFront from making its own origin request</li><li>we also need to be sure CloudFront does not cache the response from our function</li></ul><p>The association that best fits our requirements is Viewer request.</p><h4>Creating Our Lambda@Edge Function</h4><p>To start, we need to create a Lambda function with a Node.js 18.x runtime. Because <a href="https://www.anthemiq.com/">AnthemIQ</a> is a single-page application (SPA), you will notice the below function code only serves index.html. This is the only file that needs security headers attached to it. The following is the function code (note the strings that need to be replaced):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6dad13be84f741fb815ac6f1ee023eaa/href">https://medium.com/media/6dad13be84f741fb815ac6f1ee023eaa/href</a></iframe><p>We are not using any 3rd party modules (except what’s already provided by AWS), so there’s no need for npm. It’s very straightforward:</p><ol><li>fetch the original index.html from S3, but only if the ETag has changed</li><li>generate a nonce</li><li>inject it onto the script tags in the index.html</li><li>return the modified index as the response, along with the CSP header</li></ol><p>You won’t be able to test your function until you have configured the IAM role properly. AWS will have created an execution role for your Lambda, so load up IAM, click on Roles, and search for your Lambda function name. Open the role and select the Trust relationships tab. You need to add edgelambda.amazonaws.com to the existing Service array. Now click on the Permission tab and edit your policy. This is the <em>most open</em> version of a policy that will work, but I recommend following the principle of least privilege:</p><pre>{<br> &quot;Statement&quot;: [<br>  {<br>   &quot;Action&quot;: [<br>    &quot;logs:PutLogEvents&quot;,<br>    &quot;logs:CreateLogStream&quot;,<br>    &quot;logs:CreateLogGroup&quot;<br>   ],<br>   &quot;Effect&quot;: &quot;Allow&quot;,<br>   &quot;Resource&quot;: &quot;*&quot;,<br>   &quot;Sid&quot;: &quot;&quot;<br>  },<br>  {<br>   &quot;Action&quot;: &quot;s3:GetObject&quot;,<br>   &quot;Effect&quot;: &quot;Allow&quot;,<br>   &quot;Resource&quot;: &quot;*&quot;,<br>   &quot;Sid&quot;: &quot;&quot;<br>  }<br> ],<br> &quot;Version&quot;: &quot;2012-10-17&quot;<br>}</pre><p>Now you will be able to test, deploy, and publish your Lambda function, after which we’ll set up CloudFront to use it.</p><h4>Configuring CloudFront</h4><p>Our CloudFront configuration is fairly straightforward. We have one origin (the S3 bucket where our static web files live) and 3 behaviors. Using 3 behaviors allows our SPA to function properly (serving the index.html by default). Our path patterns are as follows:</p><ol><li>index.html</li><li>*.*</li><li>Default (*)</li></ol><p>The index.html and default path patterns both run the above Lambda@Edge function, returning the index.html with the desired security headers. Ensure caching is disabled on these behaviors so the nonce gets updated every time the file is served. Be sure to select the appropriate Response headers policy. Under function associations, Viewer request, select Lambda@Edge and enter your function ARN, including the version number. Do not check the include body checkbox.</p><p>The *.* path pattern matches any routes that include a filename. If your app routing uses routes that include a “.” character, then you will need to get more specific with your path pattern (i.e., use actual file extensions). For this behavior, CloudFront will fetch the file from the origin normally. We use the CachingOptimized cache policy and no security headers in this case. This configuration allows CloudFront and the user’s browser to cache the files normally.</p><p>One thing to consider with this change is service worker, especially given its caching APIs. We do not use service worker at <a href="https://www.anthemiq.com/">AnthemIQ</a>. Every request for index.html fetches the most up-to-date version. We find this best meets our needs.</p><h4>Summary</h4><p>We covered a lot of ground in this post. We explored:</p><ul><li>What are security headers and content security policy</li><li>What is a strict CSP</li><li>How Firefox prevents us from leveraging hash-based CSP</li><li>What are CloudFront and Lambda@Edge functions</li><li>How we can leverage Lambda@Edge functions to inject a random nonce onto our script tags and return a strict CSP header</li><li>How we configure CloudFront behaviors to serve our modified index.html file</li></ul><p>There were a few topics that I did not go into great detail on in order to keep the post a reasonable length. I recommend that you read the linked resources to get a complete understanding of the topics covered.</p><p>As always, I hope that you found this post helpful!</p><h3>Level Up Coding</h3><p>Thanks for being a part of our community! Before you go:</p><ul><li>👏 Clap for the story and follow the author 👉</li><li>📰 View more content in the <a href="https://levelup.gitconnected.com/?utm_source=pub&amp;utm_medium=post">Level Up Coding publication</a></li><li>💰 Free coding interview course ⇒ <a href="https://skilled.dev/?utm_source=luc&amp;utm_medium=article">View Course</a></li><li>🔔 Follow us: <a href="https://twitter.com/gitconnected">Twitter</a> | <a href="https://www.linkedin.com/company/gitconnected">LinkedIn</a> | <a href="https://newsletter.levelup.dev/">Newsletter</a></li></ul><p>🚀👉 <a href="https://jobs.levelup.dev/talent/welcome?referral=true"><strong>Join the Level Up talent collective and find an amazing job</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae5a6752b9b0" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/nonce-based-csp-with-aws-cloudfront-ae5a6752b9b0">Nonce-Based CSP with AWS CloudFront</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CloudFront Signed URLs with Node.js and Express]]></title>
            <link>https://levelup.gitconnected.com/cloudfront-signed-urls-with-node-js-and-express-c0602ac405a3?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0602ac405a3</guid>
            <category><![CDATA[signed-urls]]></category>
            <category><![CDATA[s3]]></category>
            <category><![CDATA[expressjs]]></category>
            <category><![CDATA[cloudfront]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Fri, 14 Oct 2022 18:04:20 GMT</pubDate>
            <atom:updated>2022-11-03T12:53:31.568Z</atom:updated>
            <content:encoded><![CDATA[<p>Layering security into an existing application</p><figure><img alt="CloudFront URL signing process diagram" src="https://cdn-images-1.medium.com/max/1024/1*tO0-DmCYlHwsHbBTtFODig.png" /></figure><p>You can find several different posts on the web about using <a href="https://aws.amazon.com/cloudfront/">CloudFront</a> Signed URLs, including several from AWS itself. However, these posts leave out a very important part of the equation, and that is how URLs are actually signed and returned to the client, especially when those URLs can be anywhere in your data schema. This post will cover the topic of using signed URLs with Node.js, Express, and MongoDB end to end.</p><p>I do assume that you have at least a working knowledge of CloudFront and S3. If you don’t, there are many posts on the web that discuss these topics in great detail.</p><h4>Background</h4><p><a href="https://www.anthemiq.com/">AnthemIQ</a> is a SaaS application that facilitates commercial real estate transactions. As a part of this service, users are able to upload documents and images, which are ultimately stored in S3. When we first started, the files in these S3 buckets were publicly accessible (if a user could discover the URLs). The issues with this basic approach are obvious. We knew we needed to secure access to the files that our users were uploading, and we quickly discovered that signed URLs were the way to do this in AWS.</p><p>URL signing is quite straightforward — without using a URL that has been signed with our private keys, access to all files in our S3 buckets is denied. The only way to get a valid signed URL is from our application backend, only after it has validated that the user has access to the file in question.</p><p>There are actually currently 2 different ways to give a user access to these files through CloudFront. Rather than signing all URLs individually, you can instead use a signed cookie. The problem with this approach, for us, is that it gives a user access to all files that are served by a given CloudFront Behavior, which does not meet our requirements. We need to control access on a file-by-file basis.</p><h4>First Steps</h4><p>Once we understood how to accomplish what we needed in AWS (more on this in a bit), we needed to plan how to actually get these signed URLs back to the client. I know that sounds super simple, but there’s more to it than you might think. Firstly, we had to track down all the URLs that were present in our data schema. Once that was done, then we needed to ensure everywhere these URLs are returned that they are being signed. Because we are using Node.js and MongoDB, we’re obviously using Mongoose as well. We could have used something like virtual functions on our Mongoose schemas, but these do not work for aggregations. Once you’re using aggregations, pretty much all bets are off. Trying to handle these URLs manually everywhere they are accessed in the business logic would of course be very error-prone. We had to come up with a way to ensure all URLs get signed without the developers needing to do anything.</p><p>This required us to get… creative. We didn’t come up with a great solution if I am being completely honest, but it works. We wrote an Express middleware function that replaces the send and json functions on all response objects. This function uses a regex to find known media file URLs and sign them. Here’s the TypeScript code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/54f2d45610f75e29d02043f4b8e84a31/href">https://medium.com/media/54f2d45610f75e29d02043f4b8e84a31/href</a></iframe><p>We’ll get to the actual signing code in a bit. If your API is 100% GraphQL you can actually use a custom scalar rather than this hack. We’re in the process of migrating, so we currently have a hybrid API and can’t employ that technique yet.</p><p>Now that we know how we can return signed URLs to the frontend, we also need to be able to handle the frontend sending signed URLs back to the backend (when saving data). We can’t persist them in their signed form. We need to remove all the signing parameters. This turns out to be a little bit cleaner, but we’re still more or less using Express middleware to do this. We are using the built-in <a href="https://expressjs.com/en/resources/middleware/body-parser.html#bodyparserjsonoptions">json</a> middleware function that is included in Express. This function actually takes what it calls a reviver function, which is called on every property in the request JSON, recursively. This makes it quite easy to run the values through a regex to find signed URLs and strip off the relevant query params.</p><p>OK, so we know what we need to do, at a high level, to make this work. Now, let’s get into the details of the AWS setup.</p><h4>Configuring AWS</h4><p>At this point, I am assuming that you know that <a href="https://aws.amazon.com/cloudfront/">CloudFront</a> is a CDN, and the basics of using it to serve S3 files in an optimized way. Because we are using CloudFront to serve the files, we can already turn off public access through S3. Users must use a CloudFront URL to access the files. However, this still has the same problem that anyone with the URL can load the files.</p><p>As a quick review, we will be working with distributions, which have origins (configures where the files are pulled from), and behaviors (configures how the files are served). For this purpose, we will be updating the behavior(s) associated with our S3 origins.</p><p>Before we do that, however, we will need to create a keypair and upload the public key to CloudFront. You do that under Key management &gt; Public keys &gt; Create public key. If you don’t know how to create a keypair, it’s just a few commands to do so, and there are many posts on the topic. After you upload the public key, you must also create a key group: Key management &gt; Key groups &gt; Create key group. This is all the information CloudFront needs to verify a signed URL. Once you have created your key group, you associate it with the behavior on the CloudFront distribution by enabling Restrict viewer access, selecting Trusted key groups, and selecting your key group. I would wait to do this until you have the logic to sign the URLs working first.</p><p>I also highly recommend using AWS Secrets Manager to store your private key rather than committing it to your source repository and loading it from disk. There are, of course, other mechanisms you could use to store this, but Secrets Manager is purpose-built for this kind of thing, very secure, and very inexpensive. You can even set up auto-rotation of these keys, but I won’t go into that. Adding the private key to Secrets Manager is as simple as exporting it, creating a new secret, and pasting in the private key as plaintext. Now you just need to fetch it when your backend service starts up, and it can live in memory while it’s running.</p><h4>Let’s Sign Some URLs</h4><p>So far we have determined our strategy for how and when URLs get signed, and we have stepped through the details of getting URL signing set up in AWS. Now it’s time to actually sign the URLs.</p><p>The first step is to fetch the private key from Secrets Manager when the backend is started. This is quite simple — only a few lines of code using the AWS SDK for JavaScript. The npm package you will need is @aws-sdk/client-secrets-manager . Here’s the code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c1e42cb414156d12335a7503f449453b/href">https://medium.com/media/c1e42cb414156d12335a7503f449453b/href</a></iframe><p>To sign the URL we will use @aws-sdk/cloudfront-signer . This code is very straightforward as well:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37ea2e75976580ea8aa10f7cf19f7bf0/href">https://medium.com/media/37ea2e75976580ea8aa10f7cf19f7bf0/href</a></iframe><p>Here we are simply specifying the URL to sign, the ID of the CloudFront key group, the exported plaintext private key, and the date at which the URL will expire. If no date is specified, the default is the start of the day two days from the current date (we use the date-fns package for this).</p><p>The only remaining piece is to create a regular expression (or otherwise identify the URLs that need to be signed) and plug this into the Express middleware described above (notice the calls to transformCloudFrontUrls in the first code snippet). Similarly, for all requests containing a signed URL, simply remove the signing parameters from the URL. That’s it!</p><h4>Summary</h4><p>In this post, we explored CloudFront URL signing end to end using Node.js and Express in our backend. We saw how to plug into Express to sign URLs on responses and remove signing parameters on request data. We saw what needs to be configured in AWS to support URL signing. And finally, we saw how to actually sign URLs using the AWS SDK.</p><p>Thank you for reading and stay tuned for more content like this in the near future!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0602ac405a3" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/cloudfront-signed-urls-with-node-js-and-express-c0602ac405a3">CloudFront Signed URLs with Node.js and Express</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You can teach an old dog new tricks]]></title>
            <link>https://medium.com/@kris.wong/you-can-teach-an-old-dog-new-tricks-10f88fc12852?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/10f88fc12852</guid>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Wed, 22 Jun 2022 19:24:56 GMT</pubDate>
            <atom:updated>2022-06-22T19:24:56.944Z</atom:updated>
            <content:encoded><![CDATA[<h4>A career in transition</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*1X5zNTTdR7N5TnRUPAVxrw.jpeg" /><figcaption>Photo by the American Kennel Club</figcaption></figure><p>If you have read any of my past posts, then you may recall that I am primarily focused on mobile platforms, particularly cross-platform development for mobile. That is, until about a year ago. The radio silence from this blog in the meantime is primarily due to the fact that I left that world behind, in search of a role that would broaden my horizons. I was focused on mobile for 8 years, and that’s a long time to be focused on any one thing.</p><p>Over the past year, I have found myself digging ever deeper into the worlds of AWS, MongoDB, TypeScript, Node.js, and Angular. My latest adventures have been around migrating from a REST API to GraphQL, but more on that in a future post. I have reached a point where I feel I have gained enough experience to be able to provide value to readers through my posts.</p><p>The takeaway from this post is that, while it may seem overwhelming at first to completely shift the tech stack you’re working with, especially after you have put in years of your career building valuable experience, it is not an insurmountable task. At the end of the day, a competent engineer is a competent engineer no matter the technologies you’re leveraging. If you find the right opportunity, and you surround yourself with the right team of people, many things are possible.</p><p>In my (18-year) career, I’ve gone from developing desktop applications with C++ to developing mobile apps in Java, Objective-C, Kotlin, Swift, and C++, to developing a MEAN stack application deployed on AWS. I encourage you to continue to pursue new knowledge and new areas of expertise because, after all, the technology landscape is ever-evolving, and you need to follow suit or get left behind.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10f88fc12852" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Precarious Problem of Kotlin Multiplatform on iOS]]></title>
            <link>https://medium.com/vmware-end-user-computing/the-precarious-problem-of-kotlin-multiplatform-on-ios-e7744d9b3cd?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7744d9b3cd</guid>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[kotlin-multiplatform]]></category>
            <category><![CDATA[ios-development]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Tue, 09 Mar 2021 18:21:52 GMT</pubDate>
            <atom:updated>2021-04-13T18:07:11.006Z</atom:updated>
            <content:encoded><![CDATA[<h4>A story of complexity, crashes, and distribution woes</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*BW2re0l5ygstkb-4mIFc4w.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@mparzuchowski?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Michał Parzuchowski</a> on <a href="https://medium.com/s/photos/jenga?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>It seems obvious that the Android developer community would be quick to sing the praises of a new cross-platform technology delivered by JetBrains. I too am in this camp. Meanwhile, the iOS developer community remains skeptical. I’m here to tell you they have every right to be.</p><p>I don’t mean to imply that Kotlin Multiplatform Mobile (KMM)is not a “good” solution for cross-platform mobile development. In fact, I believe it to be the best solution available for many teams. However, iOS developers <em>will</em> have a second-rate experience with this technology. There’s simply no way around that at the current time. Allow me to expand on some of the major pain points that we have encountered.</p><h4>Concurrency and Complexity</h4><p>If you have worked with concurrency with Kotlin/Native, then you already know where this is going. The concurrency story with Kotlin/Native is simply not ready for production. The JetBrains team is aware of this situation.</p><p><a href="https://kotlinlang.org/docs/mobile/concurrency-overview.html">This post</a> is a great overview of the memory model enforced by Kotlin/Native when concurrency is involved. The JetBrains team designed this memory model in an attempt to reduce many of the issues that we encounter once we start working with concurrency. However, in practice, it creates so much complexity that it becomes nearly impractical to manage it.</p><p>In terms of what needs to be frozen, when it needs to be frozen, how we work with mutable state, and even when things get frozen automatically, it quickly becomes overwhelming. In fact, the JetBrains team themselves has had trouble handling this complexity effectively. In my experience, each new release of the <a href="https://ktor.io/">Ktor framework</a> introduces new crashes on Apple platforms. Even when they manage to fix the existing crashes, they also introduce new ones.</p><p>I am not here to tell you this can’t be managed — it can. We’re managing it in our projects at VMware. You just need to be aware of what you’re getting yourself into. It’s not at all unusual for an Android developer to push a change that causes crashes on iOS. A comprehensive test suite — which includes tests that exercise code from a non-main thread, are a necessity. Meanwhile, the JetBrains team is currently designing a new memory model to reduce this complexity. You can read about this effort in <a href="https://blog.jetbrains.com/kotlin/2020/07/kotlin-native-memory-management-roadmap/">this post</a>. You should also check the Kotlin/Native section of the <a href="https://kotlinlang.org/docs/roadmap.html#roadmap-details">roadmap</a>. Specifically, <a href="https://youtrack.jetbrains.com/issue/KT-42296">this issue</a> is related.</p><p>And, the last point on this specific topic — the stable versions of the kotlinx.coroutines libraries do not even support concurrency at all on Apple platforms. Only the main thread is supported. There are “alternative” artifacts that need to be used to support worker threads. These alternative artifacts have version numbers that end with “-native-mt”, short for native multithreading. For instance, the current version is “1.4.3-native-mt”. See <a href="https://github.com/Kotlin/kotlinx.coroutines/issues/462">this issue</a> for all the gory details.</p><h4>No Support for Swift</h4><p>Kotlin/Native does not support Swift, only Objective-C. This includes both inputs (dependencies) and outputs. The tool used to support Apple frameworks as dependencies of your KMM projects is called Cinterop. Cinterop can only generate bindings from Objective-C headers, so these bridge headers must be available for any Swift framework you want to use as a dependency. Only the APIs exposed through these headers are supported.</p><p>Similarly, the framework that gets built by the KMM toolchain uses Objective-C header files. It does annotate them for more convenient naming in Swift, but that is not the same as having a pure Swift API.</p><h4>Limited Support for Native Dependencies</h4><p>KMM does support CocoaPods dependencies via the CocoaPods plugin and Cinterop tool. Unfortunately, if you have a dependency whose API is dependent on another library, this is not supported. See <a href="https://youtrack.jetbrains.com/issue/KT-38749">this issue</a> for more information. Also, C++ dependencies are not supported. A C shim API must be created in order to leverage a C++ library.</p><h4>Debugging is not Straightforward</h4><p>Your iOS developers work in Xcode. If they experience an issue in a KMM library, they need to be able to debug in order to troubleshoot. Fortunately, this is possible. Unfortunately, there are a few manual steps involved. First, they need to install <a href="https://github.com/touchlab/xcode-kotlin">this Xcode plugin</a>. They also need to have the source code for the library available locally. Depending on how you are handling distribution, that may already be the case (more on this later). Lastly, they will need to add the library source root as a folder reference in the Xcode project for the app. This makes the source files available to the Xcode debugger. After completing these steps, they will be set up for debugging.</p><h4>The Distribution Story could be Better</h4><p>Frankly speaking, this has always been the case for iOS developers. You have Cocoapods, but it is nowhere near as productive as Maven is for Java / Kotlin projects. Swift Package Manager may be a game-changer in this area, but it remains to be seen. That said, you have a few options for distributing your KMM library for use in iOS apps. <a href="https://medium.com/wantedly-engineering/different-approaches-in-consuming-kmm-modules-in-ios-7957c722b114">This article</a> goes into way more detail than I will here, so I recommend you check it out. Your two main options for distribution are:</p><ul><li>Fat framework</li><li>CocoaPods</li></ul><p>The primary issue with distributing a fat framework is that you don’t really know exactly which version is included in your source tree unless you have a strict process around how the framework file gets updated. It’s also frustrating when you are trying to iterate on changes in your library and run them in your app project (another incentive for a comprehensive test suite). It is very simple to get started with, however.</p><p>In my opinion, using the Cocoapods plugin along with git submodules is the most robust solution for distributing your library at this time. This also makes debugging a little easier, as discussed previously. You add your KMM source repo as a git submodule of your iOS app repo, and then reference the generated podspec file from the KMM repo in your Podfile. The primary issue with this option is that it lengthens the build time of your app, but if you’re using CocoaPods, you’re probably already used to that. This option is impacted by <a href="https://youtrack.jetbrains.com/issue/KT-44380">this issue</a>, though it is easily worked around.</p><h4>Summary</h4><p>In this post, I covered some of the major pain points that I have experienced in using KMM on iOS. This is by no means an exhaustive list. That being said, leveraging KMM now is certainly possible, and it’s not my intention to scare you away. At VMware, we do have multiple KMM modules that are in production. I only want to share with you some of the realities of leveraging KMM in its early days, so you can be better prepared for what the experience looks like. Regardless of whether you decide to pursue a cross-platform strategy in the immediate future, it is my personal opinion that cross-platform development will become a best practice in the long term.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7744d9b3cd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vmware-end-user-computing/the-precarious-problem-of-kotlin-multiplatform-on-ios-e7744d9b3cd">The Precarious Problem of Kotlin Multiplatform on iOS</a> was originally published in <a href="https://medium.com/vmware-end-user-computing">VMware 360</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[KMM vs. KMP — What’s the Deal?]]></title>
            <link>https://medium.com/vmware-end-user-computing/kmm-vs-kmp-whats-the-deal-dd64bc5d61f2?source=rss-12a6ea0e1302------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd64bc5d61f2</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[kotlin-multiplatform]]></category>
            <dc:creator><![CDATA[Kris Wong]]></dc:creator>
            <pubDate>Fri, 22 Jan 2021 16:44:42 GMT</pubDate>
            <atom:updated>2021-03-04T00:54:19.744Z</atom:updated>
            <content:encoded><![CDATA[<h3>KMM vs. KMP — What’s the Deal?</h3><h4>Kotlin Multiplatform goes mobile</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*KCIC3aOyo1thGgKqC35jYQ.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@alexacea?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Alexandru Acea</a> on <a href="https://unsplash.com/t/technology?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Before I begin, allow me to point out that I do not work for JetBrains, and while I do have contacts at the company, this post represents my understanding of the situation regarding these two separate, but strongly coupled efforts. This post also reflects my views as an individual practitioner and is not a formal VMware endorsement of any product or service.</p><p>Not long ago, <a href="https://blog.jetbrains.com/kotlin/2020/08/kotlin-multiplatform-mobile-goes-alpha/">JetBrains announced the availability of Kotlin Multiplatform Mobile</a> (KMM), an offshoot of Kotlin Multiplatform (KMP) with its own team focused on mobile use cases. If you have not read the announcement, I recommend that you do. This announcement, along with the introduction of the KMM plugin for Android Studio, has led to some confusion within the community. JetBrains hasn’t specifically addressed this confusion head-on. That’s mainly because the company still seems to be hammering out its strategy in this area. It is still learning how the community is using, and desires to use, its products to most effectively tackle Multiplatform use cases. With this in mind, I’d like to attempt to shed light on two separate questions:</p><ul><li>What is the difference between KMM and KMP?</li><li>What IDE/plugin should I be using for my multiplatform development?</li></ul><p>KMM and KMP are not separate projects or technologies. KMM can be thought of as a subset of KMP. While KMM has its own focused team within JetBrains (and its <a href="https://kotlinlang.org/lp/mobile/">own website</a>), it is built from the same codebase as KMP. As a developer, you do not choose (or migrate) between the two. You are either targeting mobile platforms, or you’re not.</p><p>Given this, there is no right or wrong answer in terms of which IDE (IDEA or Android Studio) you should be using for your development. It is still a little unclear how the roadmaps for the KMP plugin for IDEA, and the KMM plugin for Android Studio, will evolve. That being said, I recommend that if your project is targeting Android, that you use Android Studio for your development. Android Studio will provide you with the best experience in developing for this platform. In fact, at this time, <a href="https://youtrack.jetbrains.com/issue/IDEA-252823">it’s not even possible to use the latest Android dev tools with IDEA</a>. Additionally, if we can cut one IDE out of the mix, we may as well do so. As a bonus, the KMM plugin introduced the ability to run and debug on iOS devices from within Android Studio, which can be a big convenience. If you have web (JS) or desktop targets in your project, IDEA may be a better choice. You can even switch back and forth between the two if you find that useful. Ultimately, the choice is yours.</p><p>In summary, the mobile use case is so core to Kotlin Multiplatform, that JetBrains decided to create a team specifically to focus on it. While you can continue to use IDEA to develop your KMP projects if you want, you will find the best experience within Android Studio when targeting Android and iOS.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd64bc5d61f2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vmware-end-user-computing/kmm-vs-kmp-whats-the-deal-dd64bc5d61f2">KMM vs. KMP — What’s the Deal?</a> was originally published in <a href="https://medium.com/vmware-end-user-computing">VMware 360</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>