Articles and case studies

Read the work behind the methods: design choices, investigated failures, practical examples and the decisions they changed. Articles retain their original publication dates. When a revision adds information that became available after publication, a dated note distinguishes it from the original account.

Follow a question

Browse the archive

Use the practice collections to find related work, or browse by publication date. Writing and coding have their own entry pages and reading paths; an article has one dated address even when several collections link to it.

Writing collection · Coding collection · All-article feed · Writing feed · Coding feed

Within an article, distinguish the author’s historical account, current product guidance and any constructed teaching exercise. Follow its sources and stated test conditions when deciding whether a method fits your work.

All articles

Subscribe by RSS

  1. Engineering

    Delegate the work, not the working pattern

    AI agents need working patterns built around real dependencies and human judgment, not inherited office habits. Parallel work and meeting preparation show why.

    Rajiv Pant

  2. Writing

    What Belongs in an Opening Memo

    An opening memo should give readers a useful proposal. A fictional workshop shows what to write, what to discuss, and what should remain unshared.

    Rajiv Pant

  3. Engineering

    Hook configuration: three probes and a trust check

    Three historical hook configurations show how diagnostics guide the next experiment, with both workspace trust and the captured result checked separately.

    Rajiv Pant

  4. Engineering

    Testing an installed plugin after its hooks run

    A Python bytecode failure shows how to test an installed plugin after hook execution, while checking package integrity and application results separately.

    Rajiv Pant

  5. Coding

    Preserve publication timestamps without changing an article's calendar date

    Preserve the instant in article metadata while keeping the authored day in routes and labels. A JavaScript example covers offsets, feeds and legacy dates.

    Rajiv Pant

  6. Coding

    Testing a Codex skill: when it runs and what it produces

    Test a Codex skill with explicit, implicit, contextual, and negative prompts, then grade its output against a concrete rubric with checked examples and limits.

    Rajiv Pant

  7. Engineering

    From CSV to chart: reviewing ChatGPT’s data analysis

    Check a ChatGPT analysis from the original CSV rows through joins, missing values, and denominators, with an example you can calculate and reproduce yourself.

    Rajiv Pant

  8. Engineering

    Checking a ChatGPT research report against its sources

    Check a ChatGPT research report by matching consequential claims to primary sources, preserving conditions, and testing what its recommendation depends on.

    Rajiv Pant

  9. Coding

    Multiple folders in Codex: choosing the primary folder

    Choose a Codex project's primary folder deliberately, map Git and instruction defaults, and check folder access before a change spans multiple repositories.

    Rajiv Pant

  10. Project management

    The Action Sheet: one page for everything your AI agents still need you to do

    The decision packet's companion: after AI agents act on your rulings, one page shows what's done, what waits for your approval, and what's left for you, with the exact text ready to send yourself or to hand to an agent.

    Rajiv Pant

  11. Coding

    Prepare a checkable handoff from ChatGPT Work to Codex

    Prepare a ChatGPT Work task for Codex with a checked input folder, accepted decisions and executable expected results. Run the local example before adapting it.

    Rajiv Pant

  12. Engineering

    Checking a Release Across AI Clients

    Trace a release through its client inventory, installed files and running sessions, using a real missed client and a workbook that keeps each result distinct.

    Rajiv Pant

  13. Coding

    Turning a Failed Code Review into Tests and Repairs

    A failed AI code review becomes a practical method for turning concrete findings into regression tests, repairs and a rereview with clearly stated limits.

    Rajiv Pant

  14. Engineering

    Two vendors, one standard: running a real upgrade with synthesis engineering

    An upgrade with Claude and Codex exposed a disabled safeguard and an invisible project record. The repairs show how to test the workflow that actually runs.

    Rajiv Pant

  15. Project management

    The Decision Packet: batching AI agents' questions without rubber-stamping them

    Batch AI agents' questions into one clear review page, preserve exceptions and deliberate choices, and keep each answer tied to its evidence and authority.

    Rajiv Pant

  16. Engineering

    The migration that was finished until a stranger looked

    A synthesis engineering story about Blind-Spot Rotation: how an AI reviewer with fresh context can find gaps the original inventory and checks missed.

    Rajiv Pant

  17. Coding

    “Not found” is not “does not exist”

    Check “not found” with bounded search, positive controls and complete output. A withdrawn-draft case separates editorial status from deployment history.

    Rajiv Pant

  18. Engineering

    Choosing Local AI Models by Measuring the Machine

    Profile a computer, choose local open-weight models that fit, install them safely, and map exact artifacts to each machine with a reproducible workflow.

    Rajiv Pant

  19. Coding

    I cut my agent’s instruction file by 62% and kept every rule

    How I cut an agent instruction file from 54,825 to 21,026 bytes while preserving its rules, with a migration method and a workbook for checking their new homes.

    Rajiv Pant

  20. Engineering

    Why I built synthesis engineering to work across AI runtimes

    Why synthesis engineering separates model, runtime and state portability, preserving native strengths while keeping projects and methods under your control.

    Rajiv Pant

  21. Engineering

    My AI executive assistant writes in its own voice. My AI chief of staff writes in mine.

    Ragbot and Ragenie, EA AI and chief-of-staff AI: why my executive assistant agent writes in its own voice while my chief of staff agent writes in my voice.

    Rajiv Pant

  22. Engineering

    My design record ruled out agent-to-agent messaging. Six days later I shipped it.

    I documented why session-to-session agent messaging would fail, then built it six days later. Why a design record is not a constraint, and what actually is.

    Rajiv Pant

  23. Engineering

    What agent memory research taught me about twenty years of notes

    Tiered memory for a personal knowledge base: what MemGPT, Zep, and Mem0 teach about structuring two decades of notes so AI agents find the right ten files.

    Rajiv Pant

  24. Engineering

    AI tools should copy GitHub's identity model, not your employer's

    AI tools should give people lasting identities and organizations scoped roles. My GitHub account and shared-agent schema show why that design choice matters.

    Rajiv Pant

  25. Engineering

    What should survive when you change AI tools

    Preserve project decisions, methods, authority and evidence across AI tools, with explicit ownership of the adapters and tests that keep the work portable.

    Rajiv Pant

  26. Engineering

    A green config is not a working agent

    Check source, installation, live behavior, continuity and capability. Use native client adapters and shared outcome tests to earn trust in an AI environment.

    Rajiv Pant

  27. Engineering

    I gave my AI agents a chief-of-staff job description

    AI agents as chief of staff: how I encoded absence coordination, notification tiers, send gates, and silent-failure validators into open-source config.

    Rajiv Pant

  28. Writing

    Anonymization Is Not Name Removal

    Scenario details can identify people after names are removed. Five practical tests: precedent, provenance, negativity, identification, and aggregation.

    Rajiv Pant

  29. Engineering

    Ask Your AI to Refute You

    Commission AI reviewers to challenge your claims, then test their findings. Use distinct lenses, concrete counterexamples and honest unresolved states.

    Rajiv Pant

  30. Writing

    Honest labels for AI-assisted correspondence

    Honest labels for AI-assisted correspondence: three lanes that tell recipients whose words they're reading, from executive staff practice to Ragbot and Ragenie.

    Rajiv Pant

  31. Coding

    What My Checks Missed After an AI Agent Deleted 474 Files

    My first checks of a bookmark cleanup passed. A second extraction found 196 missing URLs. The case shows how to check preservation against the source inventory.

    Rajiv Pant

  32. Coding

    When a Commit Guard Cannot Run, It Must Block

    A missing Python dependency let my commit guard pass without scanning. Distinguish clean results from broken checks, test exceptions and monitor guard health.

    Rajiv Pant

  33. Methods

    AI disclosure guards: approval is the boundary

    Build AI disclosure guards around approved facts, their sources and where they will appear, with a precedent ledger and five practical contextual review tests.

    Rajiv Pant

  34. Coding

    I told a sub-agent to check before committing. Minutes later, I didn't.

    Three multi-agent coding incidents taught me to inspect the shared Git index, write concrete briefs, and keep untested claims visible through every handoff.

    Rajiv Pant

  35. Engineering

    Your AI assistant’s memory should belong to you

    Check whether AI memory survives a change of tool or machine, using my 35-file audit and a practical handoff test for a durable, versioned project record.

    Rajiv Pant

  36. Engineering

    I built a validator for Google’s Open Knowledge Format

    Check an OKF v0.1 bundle against its specification, distinguish checker coverage from conformance, and preserve knowledge and navigation during conversion.

    Rajiv Pant

  37. Engineering

    When I use chat, workflows, and a visual console

    How I choose between chat, repeatable workflows and a visual console, while keeping project records I own and deciding what must survive a change of tools.

    Rajiv Pant

  38. Coding

    Your Coding Agent Should Watch Its Own Work Run

    Use authorized browser actions, screenshots and state checks to test a coding change in the running app, keeping visual and behavioral evidence distinct.

    Rajiv Pant

  39. Writing

    Where AI assistance ends and the writer begins

    Where AI assistance ends and the writer begins: whose experience, whose position, whose voice. Three provenance questions draw the line, not a percentage.

    Rajiv Pant

  40. Coding

    Prompt discipline is engineering infrastructure

    Prompt discipline is engineering infrastructure: a forbidden-phrase catalog, hooks, and enforcement that catch AI coding agents dressing shortcuts as judgment.

    Rajiv Pant

  41. Writing

    Slop detection, not AI detection

    Slopcheck separates style cues from substance so editors can examine claims, preserve a writer's meaning, and decide whether a draft deserves publication.

    Rajiv Pant

  42. Coding

    The architecture of an open-source slop detector

    How Slopcheck combines analysis planning, hosted controls and shared routing for a free public tool, with source tests of cost, data and enforcement boundaries.

    Rajiv Pant

  43. Methods

    An AI writing catalog should keep its history

    Keep dated writing patterns, examples and review decisions so editors, researchers and tool builders can improve the catalog without losing what it has learned.

    Rajiv Pant

  44. Coding

    One context file carried a redesign across eight AI sessions

    A single CONTEXT.md carried an editor redesign across eight AI coding sessions. The ownership split that made it work: humans direct, the AI keeps the record.

    Rajiv Pant

  45. Engineering

    Synthesis engineering needs a pedagogy, not just a methodology

    A methodology tells practitioners what to do. A pedagogy forms judgment. What the Bauhaus teaches about growing synthesis engineering beyond its founders.

    Rajiv Pant

  46. Coding

    Three Ragbot releases, one architectural shift

    How Ragbot’s three releases joined local models, tools, skills, memory and policy into a conversational runtime, with the engineering choices behind the shift.

    Rajiv Pant

  47. Coding

    Every bug report is now a patch-or-redesign decision

    The minimal patch is a habit from when understanding was expensive. AI coding agents ended that economy, and most of us never consciously make the choice.

    Rajiv Pant

  48. Engineering

    Directing an AI assistant across search and hosting tools

    Directing an AI assistant through Search Console, Bing and Cloudflare kept a recovery moving while I made the decisions, checked results and managed exceptions.

    Rajiv Pant

  49. Writing

    Introducing synthesis writing

    An introduction to synthesis writing: keeping authorship human, using AI for supporting work, and respecting writers who choose not to use these tools.

    Rajiv Pant

  50. Coding

    Postel's Law for AI-Written Documents

    Three bugs in my daily-plan dashboard led to shared vocabulary and tolerant rendering. The case shows where strict contracts belong and how to check both sides.

    Rajiv Pant

  51. Project management

    I made project memory portable between Claude Code and Codex

    Carry project decisions, unfinished work, and verification between Claude Code and Codex while checking each tool's instructions, skills, hooks, and access.

    Rajiv Pant

  52. Coding

    Demo mode as a pattern for software

    Build demo mode into software so users can explore it with realistic sample data. A console case shows the design, testing, privacy and onboarding choices.

    Rajiv Pant

  53. Coding

    Synthesis Console: open-source tooling for synthesis engineering

    I built a local console for projects, lessons and daily plans. File conventions, a small dependency budget and portable configuration shape its architecture.

    Rajiv Pant

  54. Coding

    Transferable Knowledge: The Fifth Pillar of Synthesis Coding

    Transferable Knowledge makes AI-assisted work useful across people, tools, crafts, time and organizations through shared decisions and maintainable code.

    Rajiv Pant

  55. Coding

    When All Tests Pass, Check the Whole Change

    A missing field survived 1,297 passing tests. Trace it from request to database, check each service and use seven review passes to find incomplete changes.

    Rajiv Pant

  56. Coding

    Stop asking me: Claude Code permissions for authorized work

    Reduce repeated prompts with a scoped Claude Code permission policy, distinguishing allowed commands, sandbox limits and actions that still need authorization.

    Rajiv Pant

  57. Coding

    The blast radius principle: checking targets before destructive commands

    Use path checks, previews and a tested recovery plan to limit AI-generated cleanup commands, with a complete exercise that removes no files.

    Rajiv Pant

  58. Coding

    Managing AI agent skills at scale: a three-repo architecture

    A three-repository architecture for public, private and team AI skills, with provenance, dependency boundaries and a method for merging local improvements.

    Rajiv Pant

  59. Methods

    The synthesis thinking framework: a practitioner's guide

    Apply five thinking modes to architecture, integration and daily AI collaboration, with cases connecting engineering decisions to a working methodology.

    Rajiv Pant

  60. Methods

    Thinking through a strategic decision with AI

    Five questions help leaders examine assumptions, consequences, uncertainty, analogies and user needs with AI before committing to a strategic decision.

    Rajiv Pant

  61. Coding

    Synthesis Skills: install methodology directly into your AI workflow

    Install reusable Synthesis Skills for code review, writing, and project continuity, with current setup guidance and the lessons behind the original release.

    Rajiv Pant

  62. Coding

    Synthesis merging: what happens after the first PR

    Integrate overlapping pull requests in dependency order, check the combined result, credit contributors and help the team take ownership of integration.

    Rajiv Pant

  63. Project management

    The Tiered Context Architecture: Managing AI Working Memory at Scale

    Organize AI project memory into active work, reference and history, with a worked migration, recovery checks and a practical path toward compiled context.

    Rajiv Pant

  64. Coding

    Turning code review findings into a tested upgrade plan

    Turn code review findings into an upgrade plan that preserves domain behavior, addresses urgent risks and defines evidence for each change before work begins.

    Rajiv Pant

  65. Coding

    What reviewing real codebases taught me about code review

    Reviewing the wrong branch led to better baselines, closer test inspection and clearer reports. See what comparisons prove, and what they leave unknown.

    Rajiv Pant

  66. Coding

    Recommend A, implement A: checking an AI agent’s work against the plan

    Check whether AI-generated code follows the agreed plan and whether that plan meets the requirements, using filename collisions to test both independently.

    Rajiv Pant

  67. Coding

    When Someone Else Contributes to Your Synthesis-Coded Project

    Review contributions against your current architecture, adapt what needs changing, and build the shared standards that let good work merge with less rework.

    Rajiv Pant

  68. Methods

    When AI summaries become your sources

    Keep AI summaries useful as they become organizational knowledge: preserve decisions, check their sources, and build context your teams can trust and improve.

    Rajiv Pant

  69. Coding

    Verifying AI-Written Code with Independent Checks

    Use independent expectations, parser comparisons, staged probes and reviewed dry runs to find mistakes in AI-written code before acting on its output.

    Rajiv Pant

  70. Engineering

    Why AI makes engineering discipline more valuable

    Richard Socher’s work on managing AI informs a practical framework for engineering leaders: architecture, delegation, code review, team skills and adoption.

    Rajiv Pant

  71. Coding

    Bidirectional Learning in Synthesis Coding: When Human and AI Teach Each Other

    Bidirectional learning in synthesis coding: humans teach AI through context, prompts, and review; AI teaches back by surfacing blind spots and edge cases.

    Rajiv Pant

  72. Coding

    The research lineage from recursive neural networks to human-AI collaborative development

    Richard Socher's work on representations and language-based tasks suggests five research questions for building reliable software with human-AI collaboration.

    Rajiv Pant

  73. Coding

    From learned representations to engineered context: what Richard Socher's research tells us about working with AI

    Richard Socher's work on reusable representations offers a practical lens for persistent AI coding context, architectural foundations and disciplined review.

    Rajiv Pant

  74. Coding

    Code Review That Scales: Choosing Review Depth by Risk

    Use a tiered code-review runbook to choose review depth, override the tier for consequential risks, and record what was checked, excluded or left unverified.

    Rajiv Pant

  75. Coding

    Why Engineering Judgment Matters More With AI

    AI makes engineering judgment more valuable. Four experiences show how faster implementation changes refactoring, verification and what we choose to build.

    Rajiv Pant

  76. Coding

    Diagnosing Retrieval Failures in a RAG Application

    Use Ragbot’s biography lookup to separate routing, tokenization and ranking, then trace a context-budget change through five defaults from UI to retrieval.

    Rajiv Pant

  77. Coding

    Data Format Contracts for AI Pipelines

    Timestamp, pagination, rate-limit and configuration failures taught me to define explicit data contracts, then test what each component sends and accepts.

    Rajiv Pant

  78. Coding

    Keeping Claude Code Refactors Consistent Across Long Sessions

    Keep a long Claude Code refactor aligned with its conventions through instruction-loading checks, scoped code review and tests of the behavior being changed.

    Rajiv Pant

  79. Engineering

    From Tool to Team: Managing AI as Distributed Engineering

    Parallel coding agents make engineering leadership central: define work, share context, review results and integrate changes while retaining design judgment.

    Rajiv Pant

  80. Coding

    Build the Foundation Before Scaling AI Coding

    Set architectural direction, build a complete reference feature and test the next addition. A worked API example shows what coding agents should extend.

    Rajiv Pant

  81. Project management

    Synthesis Project Management: Keeping AI Work Moving Across Sessions

    A working method for human-AI projects: keep current context small, preserve decisions and lessons, and carry useful work across sessions, people and AI tools.

    Rajiv Pant

  82. Engineering

    Synthesis Engineering: Organizing Complex Work with AI

    A discipline for organizing complex work with AI: define results, assign responsibility, check outcomes and preserve decisions, with a worked software example.

    Rajiv Pant

  83. Coding

    How Claude Code Uses CLAUDE.md and Memory

    Claude Code loads project instructions and saved memory under different rules. Check what survives compaction and whether the code follows your guidance.

    Rajiv Pant

  84. Coding

    What OpenAI's Sora Build Teaches Us About Synthesis Coding

    What OpenAI's Sora Android case teaches about synthesis coding: give agents context, establish patterns, plan changes, and lead the work as it scales.

    Rajiv Pant

  85. Coding

    Scaling Synthesis Coding in Your Organization

    Scale AI coding through a phased team rollout, role-specific training, quality standards and practical measures that build lasting engineering capability.

    Rajiv Pant

  86. Coding

    Building ownwords: A Synthesis Coding Case Study

    How I built ownwords to manage 53 articles in Markdown, with deliberate architecture, publishing checks and runnable conversion and permission examples.

    Rajiv Pant

  87. Coding

    Why Synthesis Coding Still Writes Code in the Age of LLMs

    Why better AI strengthens the case for code, shared understanding and review, with a family math puzzle, a runnable median example and three practical prompts.

    Rajiv Pant

  88. Coding

    Vibe Coding and Synthesis Coding: Two Complementary Approaches

    Use conversational exploration to test ideas and synthesis coding to build software people can depend on, with practical guidance for moving between the two.

    Rajiv Pant

  89. Coding

    Polyrepo Synthesis: Working Across Repositories with Claude Code and VS Code

    Configure Claude Code and VS Code for cross-repository work, map shared dependencies, and test both direct and indexed consumers after a schema change.

    Rajiv Pant

  90. Coding

    Modernizing a 17-Year-Old WordPress Plugin with Claude Code

    A 2025 modernization of Blogroll Links: WordPress security and compatibility work with Claude Code, and why maintaining open-web software still matters.

    Rajiv Pant

  91. Coding

    Build a self-improving AI coding practice

    Improve AI coding through project context, skills, instructions, and practice. A team account and CSV exercise show how to carry useful lessons into later work.

    Rajiv Pant

  92. Coding

    Understanding the AI-generated code you ship

    Understand AI-generated code well enough to debug and change it. A cache example connects comprehension, review, and tests to sustained development speed.

    Rajiv Pant

  93. Coding

    Quality standards for AI-generated code

    Design a testing strategy, review generated code, and connect passing checks to real requirements. An empty-response example shows how a green suite can fail.

    Rajiv Pant

  94. Coding

    Human architectural authority in AI-assisted development

    How engineers keep AI-assisted development coherent: own architectural decisions, record their rationale, and use shared constraints to reduce costly rework.

    Rajiv Pant

  95. Coding

    Reviewing Claude Code’s Work: Security and Performance

    Four Claude Code cases show how engineering review improves authentication, caching, async calls, and security findings, with runnable local Python examples.

    Rajiv Pant

  96. Coding

    The synthesis coding framework: building production software with AI

    Five connected pillars turn AI-assisted coding into an organizational practice, with project cases, planning guidance, and a path to production software.

    Rajiv Pant

  97. Coding

    Synthesis coding: a professional practice for AI-assisted development

    Architectural judgment, systematic quality, and shared project knowledge make AI-assisted development a professional practice with lasting value for teams.

    Rajiv Pant