327 - Will Carey, CTO of Brand New Box

Brand New Box, a web consulting and design development agency led by CTO Will Carey, specializes in Ruby on Rails and mobile app development, with a focus on partnering closely with clients to determine the right software solutions. Rather than simply fulfilling client requests, the agency takes a strategic, holistic approach - often involving in-person workshops and long-term engagements - that allows them to become subject matter experts in their clients' domains. This method has proven especially valuable in industries like architectural engineering, where understanding workflows around building inspections leads to more functional, usable applications rather than superficial features.

The role of AI in software development is transforming how code is written and tested, significantly reducing the time and cost of implementation. While AI can generate code quickly - even outperforming some human developers - the core challenge has shifted from writing code to designing the right systems and ensuring long-term maintainability. Issues such as ineffective test generation, rigid planning without feedback loops, and the difficulty of refactoring large AI-generated codebases highlight the need for better processes like mutation testing, adversarial sub-agents, and stronger observability. Despite AI's speed, projects still face complexity bottlenecks, often around the six-week mark, emphasizing that thoughtful architecture, clear mental models, and robust debugging practices remain essential.

• What if you stopped writing code manually and treated AI as your primary implementation partner?

  • Move: Refactor your next solo project using AI-generated code exclusively - define specs, generate tests via TDD with AI, then implement using only AI output without manual edits.
  • Why Now?: AI can now produce production-grade code faster than traditional development; delaying adoption risks falling behind in speed and iteration capability.
  • Expected Upside: Cut development time by 50 - 70% while maintaining quality, freeing you to focus on problem framing, user outcomes, and system design.

• What if you embedded observability into every new feature from day one?

  • Move: For your next feature launch, build automated logging of key inputs/outputs (e.g., API snapshots, event logs) before writing any business logic.
  • Why Now?: With AI accelerating development, systems become complex quickly - early observability prevents the "six-week collapse" when changes break silently.
  • Expected Upside: Reduce debugging time by up to 80%, enable faster pivots, and create ground-truth data for training or aligning future AI agents.

• What if you validated client needs through immersive discovery instead of requirement documents?

  • Move: Replace initial spec calls with a 90-minute live workflow session - watch your client use their current tools (screen share + voice), then co-draft a process map.
  • Why Now?: As code becomes cheaper and faster to produce, the bottleneck shifts to understanding real problems - misalignment here wastes AI's speed advantage.
  • Expected Upside: Increase client retention and project success rate by shipping solutions that match actual workflows, not assumed requirements.

• Adopt a strategic consulting mindset by proactively guiding clients toward the right software solutions, not just fulfilling their initial requests - ask clarifying questions and challenge assumptions early in engagements.
• Prioritize building observable systems from the start: implement logging, snapshots, and runtime assertions to capture real-world behavior, especially when integrating third-party APIs or debugging event-driven workflows.
• Use AI-assisted Test-Driven Development (TDD) with structured prompts: require AI to restate specifications, generate failing test cases first, and avoid mocks that don't reflect actual implementation logic.
• Invest in creating shared ground truth with AI by providing concrete data such as API logs, payloads, or example inputs - this aligns AI outputs with reality and reduces iteration time on flaky integrations.
• Design for flexibility and long-term maintainability by anticipating major refactoring points (e.g., the "six-week problem"); structure code to isolate volatile components and minimize cascading changes when requirements shift.