What Ollama Logs Teach You About Running LLMs Locally

Running a large language model locally starts simple enough: pull a model, send a request, get a response. Performance tuning is where it gets interesting.

When models run behind a cloud API, there is not much to do when something goes wrong except wait or click retry. Running models locally changes that entirely. Ollama exposes rich server logs that describe exactly what the inference engine is doing on every request. Even without prior knowledge of how LLM inference works, you can paste those logs into the model and ask questions. The answers build a working understanding of what is actually happening under the hood, one slow request at a time.

Why Agent Tool Standardization Fails in Practice

This post is part of ongoing research into AI agents and skills by Tianjie Shen, a software engineering intern at Wavether. Tianjie studies Mathematics and Economics at the University of Toronto.

Standardization bodies exist to prevent fragmentation. The Agent Skills standard was designed to enable portable skill distribution across multiple AI agents. The premise is sound: write a skill once, deploy it everywhere. However, while the Agent Skills standard establishes skill scanning in the .agents/skills directory or an agent-specific directory .<agent>/skills as a convention, not all agents respect this. The five agents Claude Code CLI, Copilot CLI, Copilot in VS Code, Cursor, and Codex all scan different paths when looking for skills and behave differently when skills with the same name appear in multiple locations. As a result, skills organized in the filesystem according to the behaviour of one agent is unlikely to work for other agents, and the agents themselves also do not provide configurability, which would otherwise allow users to manually introduce interoperability.

Comprehension Debt Is an Engineering Leadership Problem

Engineering teams adopting AI agents are generating more code than ever, and the standard signals engineering leaders rely on to assess team health show no cause for concern. Velocity metrics are up, pull request counts have climbed, and test coverage holds. DORA metrics reviewed in performance calibration meetings look healthy by any conventional standard.

What those metrics cannot capture is comprehension: the accumulated understanding of why the codebase is structured the way it is, which decisions were made under constraint, and how the system behaves at the edges. When AI agents produce code faster than any individual can reason through it, team comprehension erodes. The gap between what exists and what anyone truly understands is what Addy Osmani calls comprehension debt in a recent O'Reilly Radar piece, and it is dangerous precisely because it grows without triggering any of the standard alerts that normally reach leadership.

The response this situation demands goes beyond adding more tests or auditing individual pull requests more carefully. It requires deliberately managing pace, protecting time for learning, and reshaping expectations about where engineering judgment is expected to operate.

The Economics of AI Compute: Balancing Reasoning, Execution, and Operations in Engineering Workflows

Allocating artificial intelligence compute across the software development lifecycle remains a critical operational challenge. The most effective engineering teams treat large language models as specialized instruments rather than generalist tools. Engineering leaders must balance the premium computational depth required for system design against the high speed efficiency needed for implementation and the raw volume processing needed for maintenance. Anthropic's Claude Opus 4.6, Sonnet 4.5, and Haiku 3.5 perfectly illustrate this targeted approach, though the principle applies universally across any modern tiered model ecosystem.

Planning Major Features with AI: A Practitioner's Guide

Planning significant features that span backend APIs, data models, UI, and infrastructure remains one of the most demanding aspects of software engineering. The complexity lies not just in execution, but in the rigorous architectural thinking required to anticipate dependencies, failure modes, and long-term technical debt.

As engineering teams mature in their adoption of AI, the focus is shifting beyond simple code generation toward higher-level architectural assistance. The challenge is no longer just writing functions faster, but leveraging AI to decompose complex requirements into manageable work streams, rigorous technical specifications, and clear implementation strategies.

This article outlines a practical workflow for integrating AI into technical planning, focusing on how the right process can help teams stress-test designs and build more robust implementation plans.

Interactive PR Reviews with GitHub Copilot in VS Code

Strict code review standards - like mandatory reviews and conversation resolution - are vital for preventing technical debt, but they often introduce major bottlenecks. The current GitHub Web and UI-focused review process necessitates not only distracting context switching but also significant manual labor. Constantly toggling between the browser to read comments and the IDE to fix code breaks flow and encourages developers to skim feedback rather than engaging with it deeply.

The solution isn't to lower standards, but to improve the workflow. This post demonstrates how to handle Pull Request reviews entirely within VS Code, using GitHub Copilot to interactively fetch comments, propose fixes, and resolve threads via the GitHub CLI. By keeping the entire cycle inside the editor, you can validate changes locally and resolve feedback faster - without ever opening a browser.

Introducing Sigma Computing Embedded Analytics for Confluence

We're excited to announce the launch of Sigma Computing Embedded Analytics for Confluence - our newest connector that brings live data visualizations and analytics from Sigma Computing directly into your Confluence pages.

If your team uses Sigma to analyze data from Snowflake, Databricks, BigQuery, Redshift, or other data warehouses, you can now embed those insights directly into your Confluence documentation, project pages, and team wikis without switching between tools.

Validate Atlassian Forge Manifest in VS Code

The manifest.yml file is the blueprint of any Atlassian Forge app, defining modules, permissions, and app identity. As an app grows, maintaining a valid manifest becomes critical.

Traditionally, developers rely on the @forge/cli tool to check for errors, specifically running commands like forge lint. Under the hood, the CLI uses the @forge/manifest package to validate your file against a strict specification. However, this workflow is reactive: you make a change, switch to the terminal, run a command, and wait for feedback.

A better experience is real-time validation directly inside your editor. This allows you to catch errors as you type and leverages features like autocompletion for complex module definitions.

Setting Up Identity-Only Google Accounts with Email Forwarding

Many organizations need Google accounts for authentication only - for SSO, admin access, or identity management - without giving the user a full Google Workspace license. This guide walks through setting up identity-only accounts using Cloud Identity Free and forwarding any emails sent to these accounts to an admin or a desired email address.

Understanding the Lifecycle of useRef in React and Avoiding Stale Reference Bugs

React's useRef hook is often used to persist values across renders without triggering re-renders. However, it's important to understand that useRef only survives re-renders, not re-mounts. This distinction can lead to subtle and hard-to-diagnose bugs, especially when working with closures or asynchronous logic.