All field notes

Teams is where employees already ask questions and request things. This playbook builds a Teams agent that answers from your sources, takes bounded actions through governed tools, and runs under the tenant's identity model rather than around it.

NetSuite runs the order-to-cash and procure-to-pay cycles for mid-market companies, and its exceptions run the finance team. This playbook builds a NetSuite agent that resolves exceptions within policy and prepares the close, under the ERP's own role model.

A Shopify agent that resolves order questions, starts returns within policy, keeps the catalog clean, and flags inventory risks, with permissions that keep refunds and pricing with people. This playbook builds it for merchants who cannot afford a mistake with a customer.

A Snowflake agent that answers business questions from governed definitions, executes as the asking user, shows its query, and refuses when evidence is missing. This playbook builds it so self-service analytics does not become self-service errors.

Billing operations on Stripe is a stream of failed payments, plan changes, invoice questions, and disputes. This playbook builds an agent that handles the routine within policy and prepares the rest for people, with restricted keys that keep refunds and payouts human.

A Workday agent that answers employees from their own record, validates onboarding data, and processes rule-based transactions, with privacy boundaries enforced by permissions rather than promises. This playbook builds it under the scrutiny HR data demands.

Compose is straightforward until recomposition gets out of hand. This guide covers state hoisting, stability, list handling, navigation, and the View interoperability boundary.

Most mobile analytics implementations collect hundreds of events and answer no questions. This guide covers event design, identity, funnels, retention cohorts, and the privacy constraints that shape all of it.

Push notifications are the most direct channel an app has and the fastest way to get uninstalled. This guide covers earning permission at the right moment, notification types and the value each must deliver, frequency and relevance controls, AI-driven personalization and timing, platform rules and deliverability, measurement beyond open rates, and the mistakes that get apps muted.

React Native performance work usually starts in the wrong place. This guide covers render scope, list configuration, bridge traffic, images, and startup — measured on hardware users actually have.

React Server Components let components render on the server and send HTML without JavaScript, while client components handle interactivity. This guide explains the model, the boundary rules between server and client, data fetching and streaming, the mistakes that erase the benefits, and when the model pays off for content-heavy and AI-driven interfaces.

Users expect interfaces to update without refreshing: dashboards that move, collaboration that shows others' cursors, AI answers that stream token by token. This guide covers choosing a transport, synchronizing state and handling conflicts, presence and collaboration patterns, scaling persistent connections, streaming AI output, and the reliability practices that keep live features live.

Smart contracts are software that moves value and cannot be quietly patched, so the development process must front-load rigor. This guide walks from specification and threat modeling through language and platform choice, development with testing and fuzzing, independent audit, deployment with rehearsed procedures, monitoring, and upgrade planning, with the mistakes that cause losses.

Upgradeable contracts trade immutability for the ability to fix bugs, and that trade has to be made deliberately. This guide covers proxy patterns, storage rules, and upgrade governance.

Upgradeable contracts let teams fix bugs and evolve features after deployment, and they introduce a control that attackers and careless admins can abuse. This guide covers the immutable versus upgradeable decision, proxy patterns and their storage layout rules, governance with multisig and timelocks, migration as an alternative, and the risks that upgrade mechanisms add.

Stablecoins give businesses digital settlement without crypto volatility, and they are moving from novelty to infrastructure for cross-border payments, supplier settlement, and treasury. This guide covers how stablecoins work, the use cases where they beat existing rails, choosing issuers and chains, compliance and accounting, integration paths, and the risks to manage.

Super apps bundle many services, payments, messaging, commerce, transport, into one application with shared identity and wallet, often opening a mini-program platform to partners. This guide covers the platform model, the architecture that keeps a super app fast and secure as services multiply, partner governance, AI assistants that span services, and whether the model fits a given market and company.

SwiftUI is productive until state ownership gets muddled. This guide covers the patterns that hold up at production scale: state, decomposition, navigation, performance, and the UIKit boundary.

A token's economics decide whether a protocol or platform attracts real use or collapses under its own incentives. This guide covers defining genuine utility, supply and distribution schedules, aligning incentives among users, contributors, and investors, governance rights, value capture, simulation before launch, legal considerations, and the failure patterns that recur.

Most A/B test implementations produce numbers that look precise and mean nothing. This guide covers assignment, sample size, metric choice, the traps that invalidate results, and when not to test.

An agent in production needs the same thing any service needs at three in the morning: a runbook. This template covers health checks, the failure modes specific to agents, the kill switch, rollback, escalation, and safe change procedures, written for the person on call.

The job description says what the role is for; the specification says exactly how the agent must behave. This template is the engineering contract FISTA writes before building any agent, section by section, with what makes each testable.

Every AI project should have an evaluation plan before it has a prompt. This template defines what correct means, how the golden dataset is built, how outputs are scored, the thresholds that gate release, and the production loop that keeps quality measured.

AI incidents have causes conventional postmortems miss: a specification gap, injected content, a model change, a permission too broad. This template structures the investigation so the fix lands in the right place and the case joins the regression set.