Forem: Andrii

Problem #1/100: Why your "clean" codebase still takes two weeks to change one thing

Andrii — Tue, 21 Apr 2026 11:08:18 +0000

You've refactored the fat controllers. You moved logic into services. Your classes have single responsibilities, your methods are short, you use enums and value objects. The code looks clean.

And yet — every time the product owner asks to change how failed actions are retried, your team touches twelve files. Every time you swap an external provider, the estimate is two weeks. Every time someone asks "can we add logging here?", the answer involves a pull request across six services.

The codebase looks clean. The architecture is still tangled.

The rule

Business logic must not know what infrastructure surrounds it.

Your domain actions — the things your product actually does — should declare what happened. Infrastructure decides what to do about it. When domain actions also handle logging, failure persistence, retry scheduling, and notifications, you don't have separation. You have infrastructure wearing a service-class costume.

The example that passes code review

A workflow automation system. Multiple step types - send an email, generate a document, update a CRM record. Each step can fail, and failures need to be logged to a tracking table, recorded as a note on the deal, and retried.

Here's what the code looks like after a "clean up" refactor:

// Step A — send automated email
final class SendAutomatedEmail
{
    public function __construct(
        private NoteService $noteService,
        private StepFailureRepository $failureRepository,
        private MailerInterface $mailer,
    ) {}

    public function execute(Workflow $workflow, Deal $deal): void
    {
        $content = $this->mailer->render($workflow->templateId(), $deal);

        if (!$content->hasBody()) {
            $this->noteService->addWorkflowNote(
                $workflow, $deal,
                noteType: NoteType::EMAIL_STEP_FAILED,
                reason: 'Email body rendered empty.',
            );
            $this->failureRepository->persist(
                workflow: $workflow,
                step: $this,
                errorDetails: ['code' => StepErrorCode::EMPTY_BODY->value],
            );
            throw new \RuntimeException('Email body rendered empty.');
        }

        $this->mailer->send($content, $deal->contactEmail());
    }
}

// Step B — generate proposal document
final class GenerateProposal
{
    public function __construct(
        private NoteService $noteService,
        private StepFailureRepository $failureRepository,
        private DocumentGenerator $generator,
    ) {}

    public function execute(Workflow $workflow, Deal $deal): void
    {
        $result = $this->generator->generate($workflow->proposalConfig(), $deal);

        if ($result->failed()) {
            $this->noteService->addWorkflowNote(
                $workflow, $deal,
                noteType: NoteType::PROPOSAL_STEP_FAILED,
                reason: 'Document generation failed.',
            );
            $this->failureRepository->persist(
                workflow: $workflow,
                step: $this,
                errorDetails: ['code' => StepErrorCode::GENERATION_FAILED->value],
            );
            throw new \RuntimeException('Document generation failed.');
        }

        $this->generator->attach($result, $deal);
    }
}

This code passes review. Named arguments, enums for error codes, a dedicated repository, a note service. It looks like someone who read the books.

But it has the same structural problem as a fat controller. Every step repeats the same three-part failure ritual: log a note → persist a failure record → throw. The ritual is infrastructure - the business doesn't care how failures are tracked. The business cares that the email was empty or the document didn't generate. Everything after that is plumbing.

Now add a retry mechanism. You touch every step. Change the failure table schema. Every step. Add a Slack notification on failure. Every step. The "clean" code has the same change-propagation cost as the spaghetti it replaced.

After

// Step A — declares what went wrong, nothing else
final class SendAutomatedEmail
{
    public function __construct(private MailerInterface $mailer) {}

    public function execute(Workflow $workflow, Deal $deal): void
    {
        $content = $this->mailer->render($workflow->templateId(), $deal);

        if (!$content->hasBody()) {
            throw WorkflowStepFailed::because(
                step: $workflow->currentStep(),
                reason: FailureReason::EmptyEmailBody,
            );
        }

        $this->mailer->send($content, $deal->contactEmail());
    }
}

// Step B — same shape, different reason
final class GenerateProposal
{
    public function __construct(private DocumentGenerator $generator) {}

    public function execute(Workflow $workflow, Deal $deal): void
    {
        $result = $this->generator->generate($workflow->proposalConfig(), $deal);

        if ($result->failed()) {
            throw WorkflowStepFailed::because(
                step: $workflow->currentStep(),
                reason: FailureReason::DocumentGenerationFailed,
            );
        }

        $this->generator->attach($result, $deal);
    }
}

// Workflow runner — one place owns all failure infrastructure
final class WorkflowRunner
{
    public function __construct(
        private NoteService $notes,
        private StepFailureRepository $failures,
        private RetryScheduler $retries,
    ) {}

    public function run(WorkflowStep $step, Workflow $workflow, Deal $deal): void
    {
        try {
            $step->execute($workflow, $deal);
        } catch (WorkflowStepFailed $e) {
            $this->notes->addWorkflowNote($workflow, $deal, $e->reason);
            $this->failures->persist($workflow, $step, $e->details());
            $this->retries->schedule($workflow, $step);
        }
    }
}

What changed: Steps only declare domain facts — "the email body was empty." The runner decides what to do about it. Add retry? One file. Add Slack alert? One file. Change failure schema? One file. Steps never change for infrastructure reasons again.

The test

Pick a service class that "looks clean." Count its constructor dependencies. How many of those are infrastructure (repositories, loggers, notifiers, queue dispatchers) vs. domain (other business rules, value objects, domain services)? If infrastructure dependencies outnumber domain ones, the class is doing two jobs — it just doesn't look like it.

Which non-obvious case should be Problem #2? Drop the symptom in the comments — I pick the next article from what developers actually hit in the wild.

I help SaaS founders untangle these exact problems (and stop paying the compound interest on invisible architectural debt) at mvpforstartup.com.

Why Git Is the Ultimate Tool for Managing AI Prompts (And What You’re Missing)

Andrii — Fri, 04 Apr 2025 14:26:00 +0000

If you're storing AI prompts in a database or hardcoding them into your code, you're probably making your life a lot harder than it needs to be. In this article, we’ll show you why Git is the superior method for managing AI prompts, offering version control, privacy, and collaboration at no cost.

Using Git for prompt management is the key to unlocking faster, more efficient workflows and eliminating the common pitfalls of API-based tools. Plus, with libraries like GptSdk, you can fetch and test prompts directly from Git, streamlining the entire process. Don’t miss out on the future of prompt management!

Link: Learn More About Managing AI Prompts with Git

The Secret to Faster, More Efficient AI Prompt Management – You Won’t Believe What These Tools Can Do!

Andrii — Tue, 18 Mar 2025 17:00:00 +0000

Managing AI prompts is crucial for developers, but it’s easy to get stuck with tools that slow you down or lock your prompts into proprietary ecosystems. In our latest comparison, we dive deep into three popular AI prompt managers — PromptHub, Humanloop, and GptSdk — to reveal which one truly offers speed, control, and data security.

Whether you’re dealing with latency, privacy risks, or lack of flexibility, you’ll want to check out which tool can boost your productivity and simplify your workflow. Curious to see which tool suits your needs? Click the link below to read the full comparison!

Link: Read the Full Article on AI Prompt Management

Laravel/Symfony Upgrade like a PRO 🦄

Andrii — Wed, 27 Mar 2024 17:20:44 +0000

Hello dev.to community 👋

Today, I spent the entire day migrating a huge project from version 6.3 to 6.4 on the Symfony framework. I found myself wondering if there was a way to make it easier. Is there a method to automatically check for potential issues that could potentially disrupt the project?

Is there a tool that can potentially help overcome these problems?

I suppose the best way to address this is to cover the project with unit tests. However, in real-life projects, there are often challenges such as pressure from business stakeholders and MVP mindsets that force developers to ignore duties related to unit tests.

If there are people in the dev.to community with experience in automated package upgrades, please share your experiences in the comments.

🏂 Use Anthropic Claude in your Laravel application today 💫

Andrii — Mon, 11 Mar 2024 16:56:29 +0000

Good News 📰

Starting today, GptSdk allows you to run prompts using Anthropic Claude. Anthropic gives $5 when you create a new account for testing, so you can jump in and test whether there are any pros for your application.

If you already have an OpenAI prompt running with GptSdk, all you need to do is switch the connector for the prompt from the user interface.

If your prompt is still hardcoded 🤷, don't give up. Install the GptSdk library for free now and switch your hardcoded prompt to the Anthropic AI vendor.

Now is a great time to switch to GPTSDK📈, as it allows you to switch models on the fly🪁, especially when there are new AI announcements from market players.

How to create a valuable prompt for Open Ai 🤯

Andrii — Sat, 02 Mar 2024 17:51:36 +0000

Hey dev.to community 👋

Today, I would like to inform you about a highly valuable opportunity that can help save your time when creating a prompt.

The main issue with dynamic prompts is that the results are not repeatable. Obtaining a cool result for one set of parameters does not guarantee the same outcome for another set of parameters 🤯. Manually testing a large dataset can be a bit tricky🏓; you have to create loops, manage timeouts, and deal with other issues. However, now you can test your prompt in just a few clicks.

Try GptSdk's Bulk Run feature and test your prompt with large datasets in minutes 🚀. Simply create a CSV file with input data, upload it to GptSdk, match fields with prompt parameters, and enjoy your coffee☕️ while GptSdk handles the job.

After the bulk run, you can download the results in a CSV file or compare them in GptSdk. Choose the best results for fine-tuning your model and achieve a more reliable prompt.

Create a free GptSdk account now and stop worrying about prompt management.

If you have any questions about how it works and how it can be helpful, I am open to discussing them in the comments 🙏.

🚨OpenAi secret you should know 🚨

Andrii — Fri, 23 Feb 2024 17:40:31 +0000

I think almost everyone in the dev.to community has given OpenAI prompts a shot in the past year.😂

The first time I made a prompt, I was excited to see the results. After a few tries, I got some ideas and thought about creating a few AI products.🚀

The first tool I tried to build was for keeping an eye on crypto news 💸. It was a simple idea: analyze RSS feeds, collect content, and send it to AI for summarization. To get useful insights for crypto investments, we needed to analyze a lot of information. The best way to understand the data was to make charts. But to make a chart, we needed metrics. So, we decided to create a prompt with JSON output containing metrics. My metric was simple: a scale from 1 to 5, showing whether to buy a coin or not (1 means "should not buy," and 5 means "all in").

We launched the first version of the tool, looked at cryptonews for two weeks, and saw that the chart was completely empty. I checked a few log records and found out the results had invalid JSON. That disappointment led to a good idea that has helped me make many successful JSON prompts. In the System section, make sure to tell the AI that it's a RESTful JSON API and give an example of the output. You can see my example in the screenshots below.

After these updates, the results were really good. I finally got a useful chart. So, the main trick with OpenAI is to use it like a RESTful JSON API.

Give it a try yourself with my example at https://gpt-sdk.com. Just create a free account and explore what you can do.

🕵 What You Didn't Know About AI Integration for Laravel Applications

Andrii — Fri, 16 Feb 2024 17:26:29 +0000

🚨 Great news for Laravel developers!

We're working on a package called GptSdk that allows you to build AI features in Laravel applications in minutes.

What we know about AI features? In general, it should be a prompt and something that transforms prompt output into user-friendly results. That's all. But for every successful project, there are huge backend tasks: continuous updates of business logic, new requirements, and adapting to new market trends. Hard-coded prompts can quickly become a pain. 💩

If you've encountered this problem or have decided to embark on your AI journey, consider trying the GptSdk package, available at https://github.com/growthapps/gptsdk.

All you need to add AI features to your app today is to:

Install the library.
Create a free GptSdk account at https://gpt-sdk.com.
Define your prompt.
Add a small snippet to your codebase:

$gptSdkClient = new GptSdkApiClient(
    HttpClient::create(),
    '<your api key here>'
);
$promptRun = $gptSdkClient->runPrompt(
    new PromptRun(
        vendorKey: VendorEnum::OPENAI,
        promptMessages: new ArrayCollection(
            [
                new PromptMessage(
                    role: 'User',
                    content: 'Hello gpt! How are you? Reply in [[tone]] tone.'
                )
            ]
        ),
        promptKey: 'hello_prompt',
        params: new ArrayCollection(
            [
                new PromptParam(
                    type: Type::STRING,
                    key: 'tone',
                    value: 'angry'
                )
            ]
        ),
    )
);

That's all! The next step is to enjoy AI integration and move forward in building great applications. 🦄