Software Engineering

Trace a document request through retrieval and inference to see how compute, memory, networking, power, cooling, throughput, and utilization affect costs.

Compare 12 months of costs for an internal AI document service, including setup, subscriptions, maintenance, usage, and migration.

Separate model quality from customer outcomes, then evaluate data, workflow, permissions, and switching costs in a hypothetical document service.

Compare flat-rate, usage-based, and hybrid pricing for a hypothetical document service. Set included usage, handle failures and trials, and check the margin on extra tasks.

Calculate the cost of a successful AI task from model calls, retries, and incremental expenses, and see how caching and quality change the result.

Separate VAT, development subscriptions, infrastructure, and usage costs to calculate contribution margin and break-even for a hypothetical AI service.

Use a search feature to connect task requests, contracts, context, model choice, implementation, verification, handoff, and PR review with Claude and Codex.

Split coding tasks between Claude and Codex and isolate changes with Git worktrees. Define file ownership and API contracts, check shared ports and databases, and integrate results sequentially. Learn to resolve conflicts, verify the integrated feature, and compare time and cost.

Learn how to resume long-running work with Claude and Codex. Record the goal, code state, verification evidence, and next action, then check them against the repository. Understand how conversation compaction differs from resuming a session and how to check uncommitted changes and stale records.

Learn how prompt caching can reduce the cost of repeated input with Claude and Codex. Arrange stable instructions and task data, interpret OpenAI and Anthropic usage, and diagnose misses. Compare the controls available in APIs and coding tools, then verify the impact on total cost and quality.

Measure Claude and Codex token usage alongside actual development efficiency. Track completion, human rework, time through verification, and cost per completed task. Include failures and stops, compare under the same conditions, and use the results to choose improvements.

Verify code changes made by Claude and Codex, from reproducing the failure through type checks, tests, and browser behavior. Use a search filter example to write a regression test, report failures, decide when to stop retrying, and document what was checked and what remains unverified.

Choose models and reasoning effort based on the difficulty and risk of an AI coding task. Define starting routes and escalation rules for quick edits, routine implementation, and complex design or verification, then compare Claude and Codex on cost, latency, and quality.

See when skill descriptions, instructions, MCP tool definitions, and tool responses enter an agent's context. Compare Claude Code and Codex loading patterns and reduce token usage by loading only what the task needs.

Give AI coding agents a clear goal, scope, constraints, completion criteria, verification steps, and boundaries for decisions. Use a practical request template to improve implementation and reduce review rounds.

Organize repositories so coding agents can find the information each task needs. Separate AGENTS.md, task documentation, and scoped directory guidance to reduce rework and connect shared and local rules in monorepos.

Design AGENTS.md and CLAUDE.md without duplicating rules. Separate shared and tool-specific guidance and use templates that fit how Codex and Claude Code load instructions to reduce context costs and rework.

Reduce token usage and rework when developing with Claude and Codex. Define task scope, organize repository instructions, narrow tool output, and build a verification loop with practical templates, a checklist, and comparison metrics.

Review the previous 14 installments, see how TDD helps with maintenance, and explore what to learn next. Includes the complete example code repository.

Explore the costs, schedule pressures, and team buy-in involved in adopting TDD at work, and learn how to choose what to test.

Compare unit and integration testing in Spring Boot, and build an end-to-end integration test using @SpringBootTest and a controllable Clock bean.

Learn how to extend an existing project with a new discount policy using TDD while keeping its existing behavior safe.

Learn what makes code difficult to test, including hidden dependencies on time or randomness, and use dependency injection to make it testable.

Test input validation and business exceptions with @Valid and @RestControllerAdvice.

Test the Controller layer with @WebMvcTest and MockMvc, and learn to verify API requests and responses.

Explore Mockito in depth: understand state versus behavior verification and learn to isolate dependencies using Mock objects.

Replace an in-memory store with a JPA Repository and use @DataJpaTest to test database logic in isolation.

Learn why TDD should start with domain services and business rules before the web controller, and how to test domain objects independently.

Learn how to complete the Refactor step of TDD by improving internal structure and separating responsibilities with confidence from tests.

Explore TDD’s Green stage: fix compilation errors and learn the minimal implementation principle for passing tests in the simplest way.

Learn how to turn requirements into test cases and write failing tests (Red) before implementing a feature.

Set up a Spring Boot project for TDD and learn the basics of JUnit 5, AssertJ, Mockito, and test package organization.

Learn the fundamentals of TDD and the Red-Green-Refactor cycle, and see why test-driven development is useful in a Spring Boot environment.

Learn to identify objects and classes, assign responsibilities, and apply encapsulation, abstraction, and polymorphism in object-oriented design.

Learn to define system boundaries and external interfaces with context diagrams, then visualize workflows, decisions, and parallel tasks with UML activity diagrams.

Learn about actors, use cases, and scenarios, and write a use case specification with basic, alternative, and exception flows.

Explore techniques for requirements analysis, a key stage in software development. Learn the strengths and use cases of formal and informal analysis, interviews, surveys, workshops, observation, and the Requirements Traceability Matrix (RTM).

Understand why a software requirements specification matters, what it contains, and how to write functional and nonfunctional requirements with concrete examples.

Learn the roles of models, views, and controllers and how they interact, with Java examples and comparisons across frameworks.

Compare the software life cycle with Waterfall, Iterative, and Agile models, and learn how to choose an approach for a real project.

Explore the core object-oriented design principles SOLID (SRP, OCP, LSP, ISP, DIP). Learn what each principle means and why it matters through Java examples, and how to apply them to build flexible, maintainable software.

Learn how to visualize system functionality with UML use case diagrams, including actors, system boundaries, and include and extend relationships.

Explore why software requirements change and learn flexible strategies for managing those changes, including change control, traceability, communication, and practical tools.

Learn to distinguish early ideas from concrete functional requirements, separate your assumptions from user needs, and use prototyping and documentation to guide a project.

Review Scrum, XP, and Kanban, learn from real-world agile adoption successes and challenges, and see how teams apply iteration and feedback.

Compare iterative development with Waterfall, understand evolutionary prototyping, and learn the Agile Manifesto values and principles.

Learn how to validate designs and gather user feedback with throwaway, evolutionary, low-fidelity, and high-fidelity prototypes.

Understand UML sequence diagrams through lifelines, message types, activations, control frames, and a practical use case that shows how objects collaborate over time.

Learn the core parts of UML class diagrams—classes, attributes, methods, and relationships—and how to visualize software design.

Software verification and validation, inspections, testing stages, black-box and white-box testing, and equivalence partitioning.

Unit testing, regression tests, drivers and stubs, JUnit assertions, fixtures, and test-method structure.

Turn UML design class diagrams and interaction diagrams into classes, method bodies, and collection-based implementations.

Understanding visibility when designing interactions between objects.

Use case realization and operation contracts in object design with GRASP.

An introduction to the nine GRASP patterns, object responsibilities, coupling, and cohesion in software design.

Design class diagrams, association perspectives, keywords, stereotypes, and deriving classes and code from interaction diagrams.

An overview of UML interaction diagrams, including sequence and communication diagrams and the messages, links, creation, numbering, iteration, and call types they represent.

Object-level design in software engineering, including static and dynamic models.

An overview of logical architecture design in software engineering, including layers, UML package diagrams, and the separation of models and views.