Episode 1: AI Can Write Code: Understanding the System is Still the Hard Part

Code generation begins with an instruction. Engineering begins with questions.

A request that says, "set this field when a sales order is created," sounds straightforward. That sentence describes what's visible, not what's actually involved. Before writing anything, we want to know which sales orders should be affected and how those orders get created. We also need to know whether another customization already sets the field, whether existing values should be preserved, and what happens during CSV imports, web services, or scheduled processing.

The field may also feed a downstream process: a report, a workflow, an integration, or an operational decision that depends on its value. New logic that changes that behavior can do exactly what was requested and still create a much bigger problem.



These questions are the real work, not a delay before it.

AI can help us investigate the system: search code, summarize dependencies, compare patterns, and flag scenarios worth testing. What it can't do reliably is recover context that was never written down or handed to it in the first place.

When the prompt contains only the ticket, AI sees only the ticket. The ticket is rarely the whole system.

The difference between producing code and engineering a solution has always been context.

AI is often effective at local correctness when we provide a clear instruction. System correctness requires knowledge of architecture, historical decisions, platform behavior, operational constraints, and consequences beyond the immediate file.



In NetSuite, execution context can change the result. A script that behaves as expected during a user-created transaction may behave differently during a CSV import or an integration request. The deployment type, event timing, related workflows, and existing customizations all shape the outcome, and a technically valid script still needs to fit those conditions.

That's why easier code generation doesn't make engineering judgment less valuable. It makes judgment the part of the work that can't be skipped.

As the cost of producing an implementation decreases, responsibility shifts toward defining the right problem, supplying the right context, and validating the result. The valuable engineer isn't the person who can produce code fastest, but the person who can determine whether that code should exist in the first place.

Using AI responsibly starts before asking it to write code. We first map the surrounding system, including entry points, related scripts, workflows, integrations, deployments, and business processes, and look for existing patterns and understand why they were chosen.

Making assumptions visible matters just as much. If the requirement doesn't explain what should happen during an import or integration, we state that gap clearly rather than letting AI quietly choose an answer on our behalf.

We then ask AI to investigate before asking it to implement. Useful prompts include:

• What dependencies could affect this behavior?
• What assumptions is this solution making?
• Which execution contexts should we consider?
• What existing logic might conflict with this change?
• What failure cases should we test?



The answers aren't automatically correct. Their purpose is to broaden the investigation and help us identify questions the original ticket may have missed.

A NetSuite-specific review also means checking the proposed script against the platform's actual behavior. If the recommendation uses SuiteScript APIs, we review whether the selected module and event context fit the requirement. We consider whether a User Event is appropriate for the timing, whether a Map/Reduce process is better suited to larger asynchronous work, and whether the script could create conflicts with workflows or other deployments. We also weigh governance usage and how failures will be detected.

The recommendation still needs to be tested against the actual system. We check the platform documentation, trace the business process, review related customizations, and test the cases that matter, confirming the proposed solution fits the architecture instead of merely satisfying the prompt.

AI can accelerate each of these steps. Accountability still belongs to the engineer.