DEV Community

Cover image for AI Can Write Code. But Who Takes Responsibility for the Software?
Saleh Ahammed Noor
Saleh Ahammed Noor

Posted on AI-assisted

AI Can Write Code. But Who Takes Responsibility for the Software?

AI can generate code in seconds.

It can build components, write API endpoints, generate database queries, refactor existing functions, and help troubleshoot complex errors.

But after working on real-world SaaS products, AI integrations, and production applications, I've realized something:

Writing code is becoming easier. Delivering reliable software is still an engineering challenge.

And that distinction matters more than ever.

AI Can Build Features. But Can It Understand the Business?

Let's consider a subscription-based SaaS application.

An AI coding assistant can generate:

  • Authentication and authorization.
  • Subscription management.
  • Payment integrations.
  • Database migrations.
  • Admin dashboards.
  • API endpoints.

But what happens when a payment fails?

Should the subscription remain active?

What if a webhook is delivered twice?

What happens when a user upgrades a subscription while an existing billing operation is still processing?

These aren't just implementation questions. They require understanding business rules, system architecture, data consistency, and failure scenarios.

AI can help implement the solution, but someone must take responsibility for deciding whether that solution is correct.

Three Real Engineering Lessons From My Work

I want to share three situations from projects I've worked on that demonstrate why engineering judgment still matters.

1. When Laravel Works Locally but Fails in Production

While working on a Laravel 13 application deployed on shared cPanel hosting, I encountered an interesting production issue.

The Laravel scheduler was failing because the hosting environment had disabled proc_open().

The application worked locally, but production behaved differently.

After investigating the framework execution flow, I identified that scheduled Artisan commands were being executed through Symfony Process, which relies on process execution capabilities.

Simply changing the command or adjusting the cron expression wouldn't solve the underlying problem.

The solution was to redesign the affected scheduled operations using Laravel's in-process scheduling approach with Schedule::call() and Artisan's in-process execution where appropriate.

This experience reinforced an important lesson:

Production engineering is about understanding the environment, not just writing code that works on your machine.

An AI assistant can help investigate framework internals and suggest solutions. But the engineer must understand the actual hosting constraints and validate the fix against the production environment.

2. Building an AI-Powered Video Generation Pipeline

I've also been working on an AI-powered short-video generation platform.

The goal is to turn a story into a complete vertical video using multiple AI-powered stages.

The pipeline involves:

  • Story generation.
  • Cartoon image generation.
  • Text-to-speech.
  • Background music.
  • Captions and timing.
  • Video composition and rendering.

Each stage introduces its own technical challenges.

Generating an image is one problem. Making that image work consistently with narration, captions, timing, and the final video is another.

For the rendering stage, I worked with FFmpeg to assemble the generated assets into vertical videos.

One of the validated smoke renders produced a 30-second, 1080×1920 video with H.264 video and AAC audio.

The important engineering work wasn't simply generating individual assets. It was coordinating multiple components into a predictable production pipeline.

This is where AI-assisted development becomes powerful.

AI can accelerate implementation, but system orchestration, error handling, timing, resource management, and output validation still require engineering decisions.

3. When the Best Solution Isn't the Most Powerful Technology

Another interesting challenge came from building a children's storybook SaaS platform.

One requirement was generating PDFs containing Bengali text.

Initially, the PDF generation approach encountered Bengali font-shaping problems.

This wasn't simply a matter of changing a font.

Bengali text requires proper shaping and rendering support. A solution that works for English text may not produce correct Bengali output.

Headless Chromium provided a more suitable rendering approach, but it introduced another infrastructure consideration.

The target shared hosting environment had restrictions around persistent browser binaries and process execution.

So the challenge became bigger than PDF generation.

It involved balancing:

  • Rendering correctness.
  • Hosting compatibility.
  • Server resources.
  • Deployment complexity.
  • Long-term maintenance.

A technically powerful solution isn't necessarily a practical production solution.

Understanding the deployment environment before choosing an architecture is just as important as implementing the feature itself.

What These Experiences Taught Me About AI-Assisted Development

These projects changed how I approach software development.

I no longer think of development as simply translating requirements into code.

I see it as a complete engineering process.

My current approach looks something like this:

Step 1: Understand the Problem

Start with the business requirement, not the programming language.

Identify the expected outcome, constraints, integrations, and edge cases.

Step 2: Design the Solution

Define the architecture, data flow, business rules, and infrastructure requirements.

AI can help explore alternatives, but the final decisions need engineering judgment.

Step 3: Use AI to Accelerate Implementation

Let AI coding tools handle repetitive implementation work, generate boilerplate, explore unfamiliar technologies, and assist with debugging.

The objective isn't to write more code manually.

It's to deliver better solutions efficiently.

Step 4: Validate Everything

Review the implementation.

Test business workflows.

Check security, performance, integrations, and failure scenarios.

Never assume generated code is production-ready simply because it compiles.

Step 5: Own the Delivery

Deployment, monitoring, documentation, maintenance, and future improvements are all part of software delivery.

The responsibility doesn't end when the code is generated.

The Future Belongs to Engineers Who Can Deliver Outcomes

I believe AI is changing the economics of software development.

The value of knowing a particular programming language remains important, but the ability to solve business problems across different technologies is becoming increasingly valuable.

A good engineer should be able to:

  • Understand unfamiliar technologies.
  • Choose appropriate tools for the problem.
  • Design maintainable architectures.
  • Integrate different systems.
  • Use AI effectively.
  • Identify risks before deployment.
  • Take ownership of the final result.

AI makes implementation faster.

But speed without engineering judgment can produce expensive mistakes.

The real competitive advantage isn't knowing how to ask AI to write code. It's knowing what should be built, how it should work, and how to make sure it works reliably in production.

That's the kind of engineering I want to focus on.


Building Something?

I work with businesses and agencies to turn ideas and operational challenges into practical software solutions.

From custom web applications and SaaS platforms to AI integrations, workflow automation, and complex system integrations, my focus is on delivering reliable, production-ready solutions.

If you're planning a software project or looking for a technical development partner, feel free to connect with me on LinkedIn or reach out to discuss your project.

Let's build something useful.

#AI #SoftwareDevelopment #SaaS #WebDev
Enter fullscreen mode Exit fullscreen mode

Top comments (0)