Forem: Dmitry Amelchenko

From Vibe Coding to SDD: Why the Future of Engineering is Architecture

Dmitry Amelchenko — Mon, 30 Mar 2026 23:02:14 +0000

The Architectural Shift

The era of writing code by hand is becoming a relic of the past. As we move deeper into the age of Generative AI, the role of the software engineer is undergoing a fundamental phase shift: from the depth of manual syntax to the breadth of architectural orchestration.

The Entropy of "Vibe Coding"

"Vibe coding"—relying on AI to generate code based on loose prompts and "vibes"—is an excellent entry point, but it carries a hidden tax: architectural entropy. Without a rigorous framework, rapid AI generation leads to inconsistencies, technical drift, and a fragmented codebase that no human brain can fully map.

Enter Spec-Driven Development (SDD)

Spec-Driven Development is the "all-in" solution to AI-driven engineering. It shifts the focus from the output (the code) to the intent (the specification).

The Engineer as Architect: In SDD, writing code is the simplest and fastest part of the cycle. The real work happens in refining the "spec"—ensuring requirements are precise, edge cases are covered, and external dependencies are identified upfront.
Contextual Superiority: While a human engineer will inevitably miss details in a massive project, GenAI can hold the entire context in memory. By using SDD, the engineer acts as a high-level validator, challenging assumptions and directing the AI to maintain a consistent vision.
The End of the Jira Bug Cycle: In an SDD workflow, the feedback loop is nearly instantaneous. Instead of an architect writing a spec and waiting weeks for a developer to validate it, the "newborn architect" (formerly the developer) can validate assumptions on the spot.

The Economics of Hyper-Productivity

The transition to SDD isn't just a qualitative win; it’s a massive economic lever. In a recent month-long experiment with Spec-driven development, I burned through over 1,000% of my monthly token allowance. The cost? $135.

To put that in perspective:

Metric	Delta
Direct Cost	~$135 (Roughly one hour of a mid-level developer's time)
Output Volume	Equivalent to 3 months of full-time manual engineering
Quality Control	Precision bug identification exceeding manual capacity

The Path Forward: Breadth Over Depth

There will be resistance. Engineers who have spent years perfecting their manual craft may feel marginalized. However, the argument is not that these skills are obsolete, but that they must be elevated.

We are moving toward a world where every pull request is a spec. The goal is to turn every developer into an architect—someone who understands the entire picture, manages dependencies, and leverages AI to execute with a speed and accuracy that was previously impossible.

The conclusion is clear: Writing code by hand is becoming "lame." The future belongs to those who positions themselves can master the specification.

Entry-Level Jobs Shift to Architecture

Core Thesis

The entry-level software engineer role is structurally obsolete. The new floor for any developer entering the workforce is architectural thinking, not code execution. GenAI compresses the time required to acquire that architectural fluency, but the expectation shift is immediate and non-negotiable.

Supporting Arguments

"Everyone becomes an architect" is not aspirational framing. It is a baseline requirement. The question of what happens to junior dev jobs is already answered: those jobs, as traditionally defined, do not survive the transition.
GenAI accelerates skill acquisition toward architectural competency, but it does not lower the bar. It raises the starting line.
This aligns directly with SDD mandate: the "developer as architect/orchestrator" identity is not a senior-level privilege. It is the entry condition.

Open Questions / Blind Spots

Hiring pipeline implications. If architectural thinking is the new floor, how do companies current hiring rubric, leveling framework, and onboarding process need to change? The thesis demands a corresponding talent strategy, not just a cultural declaration.
The acceleration claim needs stress-testing. GenAI helps acquire skills "in no time" is an assertion, not a proof. The gap between GenAI-assisted architectural intuition and genuine systems judgment (failure modes, tradeoffs, organizational context) may be wider than the framing suggests.
Resistance vector. This argument is most threatening to mid-level engineers who built identity around depth. The framing addresses new entrants but sidesteps the harder conversation: what does this mean for the engineer who has been writing code for five years and is not yet an architect?

There is C, there is C#, and there is Java—which is effectively C♭.

Dmitry Amelchenko — Thu, 12 Mar 2026 16:12:09 +0000

The End of Vibe Coding

Dmitry Amelchenko — Sun, 08 Mar 2026 03:49:49 +0000

The "Move Fast and Break Things" era has met its match in Generative AI. We are currently witnessing a split in the engineering world. On one side, there is Vibe Coding: a frantic, prompt-heavy workflow where developers describe a goal, "re-roll" until the code looks right, and pray the edge cases don't implode in production. On the other, there is Spec-Driven Development (SDD): a disciplined, architectural approach that treats AI not as a magic wand, but as a high-velocity compiler for human intent.

If you are building mission-critical systems, the "vibe" is no longer enough. Here is why the industry is shifting toward the Power Inversion—and how you can lead the transition.

The Lethal Trifecta of Vibe Coding

Vibe coding feels like a superpower during a weekend hackathon. You aren't bogged down by syntax; you are describing a vision. However, when that prototype needs to become a foundation, three structural limits emerge:

The Assumption Problem: AI hates ambiguity. If your prompt is vague, the model will aggressively fill in the blanks with its own assumptions. This leads to code that looks perfect but is quietly, dangerously wrong.
Context Decay: AI models have the "memory of a goldfish." As a project grows, the model forgets the architectural decisions you made last week, leading to a messy patchwork of local fixes.
The Accountability Gap: In vibe coding, the code is the only source of truth. You lose the audit trail of why a decision was made, making professional governance impossible.

The Solution: The Power Inversion

To harness AI without the chaos, we must embrace the Power Inversion. In the old world, "Code was King"—if the docs and the code disagreed, the docs were wrong. In the SDD world, the Specification is the Truth. If the code deviates from the spec, the code is broken and must be fixed.

This shift transforms the developer's role from a "prompter" to an Architect of Intent.

The SDD Framework: Five Non-Negotiables

To move from "unsupervised intern" AI to a "high-leverage collaborator," your workflow must integrate these five pillars:

1. Executable Intent

Your specifications cannot be dusty PDFs. They must be living, machine-readable documents (Markdown) that live in your Git repo. A spec is "executable" when it is so unambiguous that an AI can derive a technical plan and test suite from it without guessing.

2. The Clarification Gate

AI agents are eager to please, which makes them prone to hallucinating business logic. Implement a Clarification Gate: the agent is forbidden from coding until it has surfaced all ambiguities. If a requirement touches "Money," "Security," or "Data Deletion," the threshold for ambiguity is zero.

3. The Project Constitution

Every project needs a CONSTITUTION.md (different SDD frameworks may name it differently, but the concept remains the same). This file encodes your "Architectural DNA"—naming conventions, forbidden libraries, and error-handling patterns. It ensures that code written a year from now feels like it was written by the same senior architect who started the project.

4. Atomic Decomposition (Micro-PRs)

Speed is a liability if the output is too large to review. Break features into tiny, verifiable tasks. If a human cannot verify a code change in two minutes, the task is too big. This "Small Steps Philosophy" prevents Agent Drift.

5. Verification-First Governance

Done doesn't mean "the demo works." Done means:

The intent is approved.
The tests enforcing that intent are passing.
The code is a derived artifact of the spec.

The ROI of Rigor

Critics argue that SDD slows you down. The data suggests otherwise. By shifting effort upstream—spending more time on the "What" and the "Why"—you virtually eliminate the downstream costs of debugging, rework, and technical debt.

Companies like Airbnb and Google have proven this at scale, using structured AI workflows to complete year-long migrations in a matter of weeks. They didn't just get faster; they got more deterministic.

Conclusion: Your New Superpower

In an era where AI can write code nearly for free, the bottleneck is no longer typing speed or framework knowledge. The new bottleneck is clarity of thought.

Your value as an engineer is now measured by your ability to define intent with absolute precision. Stop serving the code. Start making the code serve your intent.

Is your spec a North Star, or just a vague suggestion? The choice defines the quality of everything you build.

From 18 to 3 Hours: When Gen AI Overdelivers (or Did It?)

Dmitry Amelchenko — Thu, 14 Aug 2025 02:06:39 +0000

I wanted to implement the dark mode on my pet project mobile app for a while -- could never find enough time and motivation to do it until now. Last night I finally started chatting to Github Copilot (Claude 4 sonnet model):

18 hours? No way. It will take me at least 4 weeks working on this little project solo for 2-3 hours a day after work.

Let's see what we (Copilot and I) were able to accomplish:

There are lot more screens, I'm showing only the most significant ones here.

It took about 3 hours total, talking to Copilot, asking questions, watching youtube videos while waiting for Copilot to complete the response to a particular prompt, then iterate again, and again, and again, until it was ... done!
It touched pretty much every single file in the project.
It's done a lot of heavy lifting -- produced a lot of code, and did it very fast.

If you know what you are doing (if you know what questions to ask Copilot in the right way) -- your effectiveness as a software engineer will go through the roof. Some unintended findings -- sometimes, you ask Copilot a question, but it kind of knows where you are going with it, so it does a lot more than you ask. For instance, I asked to apply a dark mode styling for a particular card which it missed on one screen, and it figured out that the rest of the cards need to have the same approach applied -- I didn't complained and accepted the change.

At this point, I ran out of steam -- going to sleep, and will release all these changes tomorrow night after work.

P.S. After proof reading this post, I realized -- one really has to keep the architecture clean (and simple) in order for Gen AI to be able to help effectively. GenAI praised this project highly, which was very flattering — all the prior decisions on the project helped to implement non trivial tasks super easily in just one session.

Before vs. After: How AI ‘Vibe-Coded’ a Mobile App Makeover That Defies Expectations!

Dmitry Amelchenko — Sun, 15 Jun 2025 19:04:58 +0000

Claude 4.0 Did in 3 Hours What Would’ve Taken Me Months

As previously stated, UI/UX is not my forte. So, today we will try to use the power of Gen AI to apply facelift on existing react-native project.

In the previous post we've looked at different AI models available in github copilot in Agent mode https://dev.to/dmitryame/design-smarter-testing-top-llms-for-mobile-interface-optimization-k89

Based on that post, the best model which will work for us is Claude 4.0.

It took two iterations -- about 3 hours combined, 22 commits total. In the first iteration I hit the rate limit, so had no choice but to punt it to the next day. Still, the amount of work that I was able to accomplish even before I hit the limit is staggering. What I was able to complete in few hours would usually take me weeks or even months.

Unlike in the previous post, where I gave different Models a high level prompt, asking to make general UI improvements, this time I went one component at a time and was very specific. I will not be sharing the details of my interactions with the Agent (it would be overwhelming) -- I will be sharing only the end results 2 screens (before and after) with some brief notes, and it will be self explanatory.

PhotosList component (landing screen)

improvements:

top nav bar
thumbnails
- more rounder corners
- redesigned indicator for video
footer redesign
- more consistent
- modern looking buttons

animation of the top nav bar (hiding text labels on scroll)

Drawer navigation (hamburger menu)

Starred Photos (empty list)

Search Photos (empty list)

improvements:

input text box
action button

Thumbs with comments on Starred and Search Photos

Photo Details screen

improvements:

dark theme
top nav bar
more modern card view approach for components:
- comments
- AI recognized tag, text, moderation
label based design for the individual tags
better colors
bottom footer redesign

Add comments screen

Zoom View Screen

Overall Tablet improvements

photos list

detailed photo view

Works on Android too (love react-native)

Extras bonus

I noticed, as the Agent was making improvements, in one of the commits it added support for Haptic feedback -- I will take it as a free bonus. Unfortunately not able to test it until the changes rolled out to prod, but hopefully they just work.

Using the right LLM for the right purpose

After making all these cool updates, releasing the mobile app to the app store is still task on its own. Especially after all these UI changes -- need to update the app store screenshots. I don't even have the right tools for slicing and dicing the images, but I do have ChatGPT, let's give it a try.

prompt: generate iTunes store screen shot image, use first image as the the most up to date screenshot and the second image as a guidelines for design, the dimensions should be 1242 × 2688px

Chat GPT:

prompt: take the mobile phone content area only from the first image and apply it to the second image in the correct place of the phone screen

Chat GPT:

prompt: you lost the headline from the second photo, apply it to the results

Chat GPT:

Well, not exactly what I was hoping for, and kind of funny results, oh well, some day soon I'm sure it will be able to do it correctly.

Let's try the same prompt with Claude 4.0 model in copilot Agent mode.

prompt:
generate iTunes store screen shot image, the output dimensions should be 1242 × 2688px, apply the screenshot which is #iphone1_1.png to the phone screen image on the #iphone1.png maintaining the proper expected screen size, position, rotation, preserve the headline on the top of the iphone1.png, final image output file name iphone1_2.png

Claude: Sorry, your request failed. Please try again. Request id: 4bd0b681-6758-4471-9c91-9c17a0231be9

Reason: Please check your firewall rules and network connection then try again. Error Code: net::ERR_HTTP2_PROTOCOL_ERROR.

and it fails today... it probably ran out of limit for the day... will have to try again tomorrow... stay tuned for more updates.

Design Smarter: Testing Top LLMs for Mobile UI Optimization

Dmitry Amelchenko — Sun, 15 Jun 2025 02:11:19 +0000

Can Gen AI Fix My Engineer-Looking UI?

My friends often comment on the software I write, that it looks like it was designed by a software engineer -- I take it as a compliment. But, there is certain truth to it -- I do not have a designers edge when it comes to creating beautiful looking UI.

Gen AI for developers, like me, could be a game changer. And this is the assumption we are about to verify. Here is the prompt: "make UX improvements of the landing screen to make it more modern". We will give this prompt to different models available in github copilot, and will document the results:

what was it able to accomplish (screenshot)
how long it took
was it able to complete the task from the first attempt, or there were additional intermittent prompts to make it work.
overall rating

For every iteration, we will wipe out the history, hard reset the git branch, and will start new session in the Agent mode with the different LLM. The prompt we will be using is purposefully somewhat high level -- we do want to push the limits to the edge and see what happens.

Here is the application we will be working on today:

https://github.com/echowaves/WiSaw

This is our starting point:

The UI of this app has not changed for nearly 2 years, it was never designed by a professional, it's fully functional, but feels slightly out of date.

GPT 4.0

prompt: make UX improvements of the landing screen to make it more modern
copilot: Unable to resolve "expo-linear-gradient" from "src/screens/PhotosList/index.js
prompt: Unable to resolve "expo-linear-gradient" from "src/screens/PhotosList/index.js

after it stopped processing ...
prompt: I do not see any visible differences to the way the screen looks

It spent less than a minute and made no changes other than empty state, which I'm not even testing for, nor care about much.
Little disappointing. Let's move on to the next model.

how long it took

about 5 minutes total

was it able to complete the task from the first attempt, or there were additional intermittent prompts to make it work.

not really

overall rating

disappointing

GPT 4.1

prompt: make UX improvements of the landing screen to make it more modern
copilot:

10 minutes later it got stuck on installing expo-linear-gradient npm
Let's kick it:

prompt: skip the install expo-linear-gradient step, it's already done, continue to the next step
copilot: The landing screen has been modernized with a gradient background, bold app title, subtitle, modern card/button styles, and a prominent call-to-action. All formatting and lint issues are resolved. Your landing screen now has a more modern and visually appealing UX.
Would you like to preview or further customize any specific elements?
prompt: yes
copilot: Great! Please let me know which specific elements or aspects of the landing screen you’d like to further customize or preview (e.g., colors, button style, icon, layout, animation, or text). I can make additional UX/UI improvements or adjustments as you wish.

what was it able to accomplish (screenshot)

No point posting the original screenshot -- no visible differences at all.

how long it took

about 15 minutes total

was it able to complete the task from the first attempt, or there were additional intermittent prompts to make it work.

not really

overall rating

disappointing

Gemini 2.5 (preview)

prompt: make UX improvements of the landing screen to make it more modern

what was it able to accomplish (screenshot)

the bottom buttons look more rounder and better aligned, other than that -- no significant differences.

how long it took

about 5 minutes

was it able to complete the task from the first attempt, or there were additional intermittent prompts to make it work.

yes

overall rating

3 out of 5

It was able to complete the task, but the changes were so minor, almost unnoticeable and not worth talking about.

Claude Sonnet 4 (preview)

prompt: make UX improvements of the landing screen to make it more modern
copilot:

7 minutes later:
copilot:

what was it able to accomplish (screenshot)

how long it took

About 7 minutes

was it able to complete the task from the first attempt, or there were additional intermittent prompts to make it work.

Yes

overall rating

4.5 stars
It was able to produce something far much better/modern looking with little (close to non) guidance. The back and forth dialog with the Agent while vibe coding was very meaningful, it was easy to understand what it was trying to accomplish, it took direction really well and dug deep in the projects code, trying to understand what should be done to fulfill the prompt the best possible way -- impressive.

Comparing the models (screenshot from ChatGPT generated summary):

Clearly, Claude 4 stands out — it was able to modernize the landing screen with little direction. Gemini did okay. GPT-4.x models were disappointing -- they underperformed in this specific context.

Conclusion: 🚀 GenAI for UI may not replace designers, but it’s already a powerful assistant — especially when paired with the right model.

Ask GPT to re-design modern looking screenshot (no coding)

What if we ask ChatGPT to generate a visual screenshot with modern UI/UX improvements based on the current screenshot of the app. Will it be able to do it? Let's give it a try:
prompt: Generate a screenshot image, which represents UX improvements of the screenshot attached reflecting modern trends and user expectations
chat GPT:

Interesting. It was able to come up with some interesting ideas for visual layout improvements. I always wanted to implement the brick layout for this app, still have to figure it out some day.

Bonus: As the last step of the exercise

I need to generate a cool looking head image for this post, let's try to use Chat GPT for that and see how well it performs:
prompt:

It took few hours, and multiple attempts -- the best image I've got from Chat GPT:

I gave various prompts trying to realign the text -- no much success, perhaps I'm still learning the proper techniques.

Lets try something different...
prompt: "create a picture 1000x420 pixels which shows comparison of the mobile apps design on different devices, screens, iOS, android, Tablets etc..."
chat GPT:

Not ideal, but will work. As I previously stated, I'm a software engineers, not a UI designer. This less than perfect image does the job for me.

In the next post we will use the winner model Claude 4.0, and, in vibe coding session, we will try to address one component at a time, and compare before and after results.

https://dev.to/dmitryame/vibe-coding-ux-improvements-for-mobile-app-before-and-after-side-by-side-comparison-h3j

Happy coding...

Redirect www to ROOT in AWS RT53

Dmitry Amelchenko — Sun, 25 May 2025 22:17:59 +0000

Why to redirect to ROOT?

Don't believe me, just type is www an anachronism in Google search. Most likely you will get response similar to the following:

What's going on in AWS.

I recently migrated my domains from Godaddy to RT53, and the process was not as straight forward as one would hope.
Route 53 offers extensive options for referencing AWS resources at the domain level, enabling better integration and making the effort worthwhile.

Most of domain registries (like Godaddy) offer convenient user interface for allowing customers to forward domains. There is no W3C standard which regulates how DNS registry providers implement domain forwarding. So it's totally up to the individual providers how to implement the forwarding.

Unlike most of the domain registries providers, RT53 does not offer the domain forwarding option out of the box. If you read documentation, it will tell you that defining CNAME record in RT53 is all you have to do. Well, it just does not work that way (based on my experience, feel free to post in comments if I'm wrong -- always looking for learn something new). The only way I could make it work, was by adding simple Edge function, which intercepts all requests to my web app, and returns the 301 (Moved Permanently) response programmatically.

Things do not work in RT53 the same way as in ... Godaddy.

Just to prove my point, here is the CNAME record I have in my hosted zone for https://wwww.wisaw.com

And, if you click the link above, it will not resolve to anything.
Let's see what is the easiest way to implement the alternative solution.

Wiring things up for the Edge function.

In your CDK stack, define the Edge function like this:


      const redirectLambdaEdgeFunction =
        // new lambda.Function( // trying to define it as an Lambda@Edge function
        new cloudfront.experimental.EdgeFunction(
          this,
          `${deployEnv()}_redirectLambdaEdgeFunction`,
          {
            runtime: lambda.Runtime.NODEJS_22_X,
            code: lambda.Code.fromAsset(
              path.join(
                __dirname,
                "../lambda-fns/lambdas/redirectLambdaEdgeFunction",
              ),
            ),
            // code: lambda.Code.fromAsset('lambda-fns/lambdas.zip'),
            handler: "index.handler",
            memorySize: 128,
            timeout: cdk.Duration.seconds(5),
            // insightsVersion,
            logRetention,
          },
        )

Assuming you are hosting your single page app on S3 bucket with CloudFront distro (read how to do it here: https://dev.to/dmitryame/serving-static-content-from-s3-bucket-195p ), add edgeLambdas section to the defaultBehavior of your CloudFront distribution like this:

      // Create the CloudFront distribution with S3 as an origin
      const distribution = new cloudfront.Distribution(this, "wisaw-distro", {
        priceClass: cloudfront.PriceClass.PRICE_CLASS_100,
        defaultBehavior: {
          origin: cloudfront_origins.S3BucketOrigin.withOriginAccessControl(webAppBucket),
          compress: true,
          cachePolicy: basicCachePolicy,
          originRequestPolicy: allForwardPolicy,
          viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS, // Add this line
          edgeLambdas: [
            {
              eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
              functionVersion: redirectLambdaEdgeFunction.currentVersion,
              includeBody: true,
            },
          ],
        },
...

The Edge function implementation.

And here is the Edge function implementation:

exports.handler = async (event) => {
  const request = event.Records[0].cf.request;

  // CloudFront headers are in format: { "host": [{"key": "Host", "value": "www.wisaw.com"}] }
  const host = request.headers.host && request.headers.host[0].value;

  if (host === 'www.wisaw.com') {
    // Build the new URL, preserving query string if present
    let redirectUrl = `https://wisaw.com${request.uri}`;
    if (request.querystring) {
      redirectUrl += `?${request.querystring}`;
    }

    return {
      status: '301',
      statusDescription: 'Moved Permanently',
      headers: {
        location: [{
          key: 'Location',
          value: redirectUrl
        }]
      }
    };
  }

  return request;
};

It's pretty straight forward and self explanatory.

Intercept all requests
If the requested host matches www.wisaw.com -- prepare the response with the redirectUrl which strips prefixing www, and
return this response with status 301

After redeploying your CDK stack -- things are expected to just work. Well, not quite yet. Keep reading.

Still need a CNAME

You still need a CNAME record in RT53 in addition to the Lambda Edge function to make it work correctly. If you have one but not the other -- it will not work. So, you need both. But adding a CNAME is easy. Here is what I've got:

Final touches.

Just to make things perfect, you will also want to make sure all your http request redirect to https. The lambda function will already do it for you if you are requesting the www subdomain. But what if you are hitting http://wisaw.com ? In the CloudFront definition of your CDK stack, there is one line of code which defines this behaviour:

          viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS, // Add this line

And that's all. Thanks for reading.

The complete code for this post --> https://github.com/echowaves/WiSaw.cdk
The web app hosted on S3 bucked with properly defined redirects is https://wisaw.com

Happy Hacking.

Serving static content from S3 bucket

Dmitry Amelchenko — Sat, 24 May 2025 20:38:46 +0000

Need for static content

Static content remains the fastest way to deliver information to browsers. As a result, many vendors now focus on optimizing it through geographic distribution, caching, CDNs, and more. Amazon is a key player in this space, offering robust solutions for efficient static content delivery.

S3 bucket, brute force approach

At the core of AWS’s storage technology is the S3 bucket, a natural choice for hosting static content and delivering it directly to the browser.
My personal preference for creating and managing s3 buckets for static content via AWS console, manually, without scripting it in CDK -- just gives me a bit more peace of mind for bucket life cycle (when it's created and deleted).

To get started, sign into your AWS console, and go to the S3 bucket section.

create a bucket with the name of your host. In my case it will be wisaw.com
in the properties tab, enable it for Static website hosting.
in the permissions tab, edit Block public access and make sure all public access is enabled by unchecking all the check boxes.
in RT53 section of the console, create or edit record type A for your domain (wisaw.com for me), and configure it as an alias to the S3 bucket (should be available in the dropdown list).

This was easy. You site should be working now, and the content delivered straight from S3 to your browser. However, I'm really not comfortable leaving the S3 bucket wide open for public access -- there has to be a better, more secure way.

Shooting for perfection -- closing all public access to S3 bucket

Go ahead and disable all public access to your bucket in console.

Before we create CloudFront distribution in our CDK script, we need to get a references to few additional resources.

Reference S3 bucket:

      const webAppBucket = s3.Bucket.fromBucketName(
        this,
        `wisaw.com`,
        `wisaw.com`,
      );

Few more things needed for `CloudFront`:

      // Use the ACM certificate
      const cert = acm.Certificate.fromCertificateArn(
        this,
        "my_cert",
        "arn:aws:acm:us-east-1:963958500685:certificate/cf8703c9-9c1b-4405-bc10-a0c3287ebb7e"
      )

      // Create cache policies
      const basicCachePolicy = new cloudfront.CachePolicy(this, 'BasicCachePolicy', {
        defaultTtl: cdk.Duration.days(10),
        minTtl: cdk.Duration.days(10),
        maxTtl: cdk.Duration.days(10),
        enableAcceptEncodingGzip: true,
        enableAcceptEncodingBrotli: true,
        queryStringBehavior: cloudfront.CacheQueryStringBehavior.all(),
        cookieBehavior: cloudfront.CacheCookieBehavior.all(),
      });

      // Create origin request policy that forwards all cookies and query strings
      const allForwardPolicy = new cloudfront.OriginRequestPolicy(this, 'AllForwardPolicy', {
        cookieBehavior: cloudfront.OriginRequestCookieBehavior.all(),
        queryStringBehavior: cloudfront.OriginRequestQueryStringBehavior.all(),
        headerBehavior: cloudfront.OriginRequestHeaderBehavior.none(),
      });

And now, Create a new `CloudFront` distribution in your CDK script:

     const distribution = new cloudfront.Distribution(this, "wisaw-distro", {
        priceClass: cloudfront.PriceClass.PRICE_CLASS_100,
        defaultBehavior: {
          origin: cloudfront_origins.S3BucketOrigin.withOriginAccessControl(webAppBucket),
          compress: true,
          cachePolicy: basicCachePolicy,
          originRequestPolicy: allForwardPolicy,
          viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS, // Add this line
          edgeLambdas: [
            {
              eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
              functionVersion: redirectLambdaEdgeFunction.currentVersion,
              includeBody: true,
            },
          ],
        },
       certificate: cert,
        domainNames: ["www.wisaw.com", "wisaw.com"],
        minimumProtocolVersion: cloudfront.SecurityPolicyProtocol.TLS_V1_2_2021,
        errorResponses: [
          {
            httpStatus: 403,
            responseHttpStatus: 200,
            ttl: cdk.Duration.days(365),
            responsePagePath: "/index.html",
          },
          {
            httpStatus: 404,
            responseHttpStatus: 200,
            ttl: cdk.Duration.days(365),
            responsePagePath: "/index.html",
          },
        ],
      });

      // Output the Distribution ID to use in the OAC bucket policy
      new cdk.CfnOutput(this, "CloudFrontDistributionId", {
        value: distribution.distributionId,
        description: "Use this Distribution ID in the OAC bucket policy for wisaw.com"
      })

Final steps

Add an alias `A` record to your Rt53 hosting zone referencing the `CloudFront` distro:

Add bucket policy in the `permissions` tab for your s3 bucket:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "AllowCloudFrontServicePrincipal",
            "Effect": "Allow",
            "Principal": {
                "Service": "cloudfront.amazonaws.com"
            },
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::wisaw.com/*",
            "Condition": {
                "StringEquals": {
                    "AWS:SourceArn": "arn:aws:cloudfront::963958500685:distribution/E37CLMKVO7KBVG"
                }
            }
        }
    ]
}

You can get the CloudFront ARN from the aws console.

Sometimes there is still a need to open public access... briefly.

The static application I host is a React.js single page app. The static content of the site is not changing frequently. But, when I need to redeploy the app (synchronize the bucket), I go to the console and enable public access for few minutes. Just don't forget to disable it again once you are done with your updates. I'm sure there is a better way, feel free to add a comment and share some cool techniques how to do it.

What if things don't work.

The example described here is a basic use case which should get you going. In real life your CDK script is expected to be a lot more complex, depending on your application. For instance, my app has few Lambda Edge functions which write to the same bucket. These function do not need public access, since they are accessing your bucket from within your account VPC.
Usually you simply have to add a following line to you CDK:

      // Grant the Lambda function permissions to read and write to the S3 bucket
      webAppBucket.grantReadWrite(generateSiteMap_LambdaFunction);

While closing public access to my S3 bucket, I ran into a situation that my generateSiteMap_LambdaFunction was not able to update the sitemap.xml stored in the bucket and was getting rejected access. I have researched tons of documentation on the web and spent few days trying different suggestions like updating bucket and function policies, configuring AIM access control etc... It turned out a silly bug that was driving me towards these complex solutions. The function writing to S3 bucket was passing one of the parameters:

 ACL: "public-read"

Since all the public access was disabled -- the function was failing. Removing that parameter fixed the problem. I was able to solve this fairly easily while vibe coding with Github Copilot. So, if you feel stuck and find yourself having to implement complex solutions for simple use cases -- there is probably a simpler answer.

Better safe than sorry.

Even if you think you have closed all public access to all your buckets, it's a good idea to still periodically check. AWS offers out of the box a tool, called IAM Access Analyzer for S3.
Running it every once in a while is probably not a bad idea:

The complete code for this post --> https://github.com/echowaves/WiSaw.cdk
The web app hosted on S3 bucked --> https://wisaw.com
Another post in this series talking about redirects in AWS --> https://dev.to/dmitryame/redirect-www-to-root-in-aws-1ee4

Happy Hacking.

Make Coding Fun Again

Dmitry Amelchenko — Sat, 26 Apr 2025 20:46:36 +0000

The Hidden Cost of a Career in Tech: Losing Motivation Over Time

During the day, I serve as an engineering manager. In the evenings, when I have the energy, I dedicate time to exploring software side projects. I don't get many opportunities to work on what I want at work. The best way to keep up with the industry trends -- is to work on emerging tech, and I've done it pretty much through out my entire software engineering career. I witnessed the inception of the Internet, I contributed to open source, I published NPM modules which got pretty good downloads, and I even had an opportunity to work on my own block chain implementation from scratch. So "I've been there, I've done that". Though, there is a little side effect which accumulates over the years -- with time it's getting more difficult to find motivation to open some old code and keep refining it. This is out of the questions -- hard. And I know, I'm not the only one who feels that way.

Time to get a foot wet with GenAI

While recently spending a week in sunny LA, I finally had an opportunity to sit down and think about the next cool side project -- something that would really be a game changer for me. I adhere to East coast work hours. Pushing myself to get up at 5:30 AM local time to be able to remotely attend my first meeting at 9:00 AM EST was hard. But... when 2 pm hits in LA, I'm free to do what ever I want. Perhaps it's time to give GenAI for coding a try.

Using GenAI for coding is a game changer

As an emerging tech, GenAI was on my radar for the past year (way too long in web years). From all the buzz on the web I started to think about GenAI as an incredibly powerful crutch for writing software. This post describes my experience using Github Copilot, which was an eye opener -- after performing this little experiment I now think of GenAI for coding as a super powerful Exoskeleton.

How to get started with GenAI for coding

There are a lot of tools and options available. Github Copilot has a free version which makes it a natural pick for most devs. First, I found a Udemy class with best reviews, and, started watching... This online class is only 7 hours long. When it comes to consuming video information, I do have short attention span -- watching the materials at 2x forces me to stay focused, and I was able to complete my initial training in 2 evenings without feeling overwhelmed.

Giving a second life to my old code

One of my oldest active projects is a photo sharing mobile app called WiSaw, which stands for "What I Saw". I also host a simple read-only web app https://wisaw.com , which is used mostly for establishing a promotional footprint on the web, so that people can find and download the mobile app. I have not touched this project in a while, perhaps it's a good time to start using new tools which were not available back then to give this project a little boost?

Asking ChatGPT for advice about improvements needed

About a year ago I started talking to ChatGPT.
Q: "what do internet users think of wisaw.com and what should be done to improve the perception".
A: "WiSaw offers a collection of free, authentic stock photos and videos. However, potential users should be aware of its moderate trust score and consider exercising caution when using the site."

After all, I never intended to make wisaw.com a real app, but, at this point, I felt, it was hurting the mobile app presence more than serving the originally intended purpose of promoting it.

The next question to ChatGPT
Q: "Hey ChatGPT, what can be done to improve the trust score for wisaw.com"
A: "Improving the trust score of a platform like WiSaw involves addressing factors that contribute to user confidence and website credibility. Here are some actionable steps:

Enhance Website Transparency
- About Page: Provide detailed information about the company, its mission, and the team behind the platform.
- Contact Information: Display clear and accessible contact details, including a physical address, email, and phone number.
- Terms and Policies: Ensure comprehensive and accessible Terms of Service, Privacy Policy, and copyright guidelines. ... (only shown the first 3 suggestion as the most relevant)."

Defining the scope

So, I have to add a top nav bar to the web app with 3 menu items. It's seemingly a simple task, right? Simple is not easy. It consists of a lot of moving parts and requires understanding of concepts like routing, page templating (headers, footers, etc...), it may require adding some additional dependencies. It's better be implemented as a responsive feature so it opens properly in any browser including mobile devices. More than trivial knowledge of HTML, JS, CSS, and how it all fits together is needed. It requires a lot of boiler plate coding and applying copy/paste design pattern. I would not find working on these tasks particularly challenging (read interesting/satisfying) -- this little project seems like a perfect candidate hand off to GenAI.

In order to get the best of Github Copilot as quickly as possible, highly recommend watching that Udemy class. It will really help to jump start your experience and avoid wasting precious time. It will tell you about different ways of interacting with Copilot (Chat mode, vs. Inline Comments, vs. Agent mode). Different versions of VSCode support various GenAI features and have access to different AI models -- you really need to know about all this to be proficient on day one.

Let Copilot do the coding

After getting through initial dev environment setup, I started interacting with Copilot in Agent mode. Agent mode is like pair programing with GenAI. Going forward I will refer to my pair programming partner as simply "Copilot".

First question I asked Copilot:

add responsive nav bar with 3 menu items "About", "Contact Us", "Terms and Policies"

And then I was just sitting and watching Copilot navigating around my project in real-time, opening the rights folders, updating the right files. Took about 2 minutes to produce fully functional code.

Here is a transcript of my interaction with Copilot (I'm posting it as a screenshots, just because it's so cool to see the real user experience):

Ha, pretty cool! It was easy, it was quick, it was FUN!

What else can Copilot do?

Here are few other things I did with the help of Copilot before publishing the changes to prod:

Q: "add default imeplementation of the about page"
Note that I even misspelled "imeplementation", but Copilot was able to understand what I'm asking.
I then spent some time on fine crafting the content manually, which was the most time consuming task, but something that had to be done.

Even more tasks:

Q: "how to make href open in new tab"

Sky is the limit -- shooting for perfection

Since I'm at it anyways, why don't I try to really make my project perfect?
Q: "fix all valnurebilities in this project"

Wow, that was quite a lot.

Turning even more boring tasks into Fun

Q: "update the project to the latests versions of dependencies, use yarn instead of npm"

The last step was particularly cool, because it demonstrated a true power of the agent mode. In the agent mode Copilot was able to open a terminal window in VSCode, execute commands, parse the output from the results of running these commands, and prompt me (the user) what to do next! Very cool!

But that's not all

I also have 2 published NPM modules which I have not opened in a while.
With the help of Copilot I was able to update expo-cached-image to the latest dependencies in no time, which is typically very laborious task.
With the help of Copilot I was able to convert expo-storage to TypeScript. I personally do not like TypeScript. I stated my career with strongly typed languages like C++ and Java, so introduction of TS felt like going back in time. But, since people want NPM's to not throw TS warnings, I had no problem converting my project, especially that I didn't have to do anything myself other than just sit and watch how Copilot does it for me.

Coding with Copilot was Fun

Doing all these boring tasks manually would take me 2 days at least. With the help of Copilot it took 2 hours at most. Even if you add 3.5 hours watching the Udemy class, 30 minutes setting up the dev environment, the productivity boost was still amazing -- more than 100%! And it was FUN watching Copilot in real-time writing code and interacting back and forth with me.

I would not expect every project to gain this much productivity with GenAI. My assumption is that the more experience you have as a software engineer -- the more gains you will be able to get from Copilot.

Since Copilot is so much better coder, should I worry about my job?

Engineers are rightfully worrying these days "is my job safe?". GenAI is great, but, who is going to define the tasks and the scope of work? Who is going to watch over its shoulder for the quality of the code produced? How do we make sure we are not going deeper into tech debt? How do we make sure our solution is "as simple as possible, but not simpler" -- "simple is not easy"? Well, this is why pair programming and code reviews were invented in the first place. I am not worried about my job and about the jobs of the engineers I'm working with on my team. GenAI tools are here to stay and they are opening up opportunities we couldn’t dream of.

P.S. I recently also started to use GenAI for writing work emails and documentation. Writing boilerplate code with the help of GenAI is a must. For instance, writing Unit Tests manually these days is a sin. However, working on the articles like this one, I choose to write every sentence by hand. I do admit, my writing is not perfect, and most likely never will be, but -- it's authentic, and it has a direct reflection of my personality. And I do intend to keep it this way. I do intend to keep improving my writing with every post, and the only way to do it -- is to keep writing with my own brain :)

Works, don't touch it? Or never ending optimization game?

Dmitry Amelchenko — Sat, 18 May 2024 15:09:24 +0000

I've built a photo sharing app https://www.wisaw.com.
I use it on my iPhone all the time, and it works great for me!

Recently a friend complained that it's really slow on his iPad. So, I started digging...

Turns out, the app retrieves the photos by calling GraphQL backend, 1 day at a time, until it fills the screen. On smaller devices works like a charm, but on tablets -- lots of network calls, and painful user experience.

My goal was to figure out how to make a backend return 10 days (or more) worth of photos in one call, without making any changes to the frontend -- it's still a pain to re-deploy mobile apps.

Here is my first bruit force approach:

This actually worked. Right away, I saw the number of calls to AWS Lambda, where I host my graphQL backend, to drastically go down. Which means the application does not have to open and maintain as many network connections on slower bandwidth networks. The UX is much smoother. So, should I stop here? Well, there was still something that bothered me about the code. To my taste, the number of repetitive lines of code is insane -- typical Copy/Paste design pattern. Generally speaking I'm OK seeing it in the code when it has 2 occurrences, but 10!!! is just a way too many.

Here is the revised version:

Much better. JS Promise.all is awesome. The final version of the code is much shorter. The number of async calls can be adjusted dynamically by playing with arraySize const. Each function call returns arrays of exactly the same objects types, so I can chain flat(1) to the end. I can probably even consider passing the arraySize, depending on the device screen size, into the lambda call at some point, but that's a different story for some other time (and that would require the mobile app new release).

So, the complexity didn't really go away, arguably, the code became even more complex. But, I thought it was pretty cool to be able to optimize UX dynamics without touching a frontend. The spikiness of the network calls moved from mobile devices running on slow networks, to calls between the middleware and the database, which are much faster and reliable.

Should I have touched the code to begin with? It was working OK after all. At the end of the day, the answer is -- yes! Absolutely! I've learned how to Promise.all dynamically on a variable size array of functions. It took me like an hour of hacking on a Friday night before heading out to a weekend.
And, I've had a lot of fun, and, my friend, who started all this, is happy running my app on his tablet -- that's all that matters.

What is the most minimalistic app you'd ever created?

Dmitry Amelchenko — Tue, 07 Mar 2023 16:04:28 +0000

I've been a big proponent of minimalism.
Especially when it comes down to engineering.
Especially for the software engineering.

Albert Einstein -- Everything should be made as simple as possible, but not simpler.

According to the second law of thermodynamics, in the physical world the entropy keeps increasing.
So does the complexity of our software, and we, the software engineers, are to be blamed.

I wrote about minimalistic architecture: https://dev.to/dmitryame/minimalistic-architecture-for-minimalistic-product-ffd

I even tried to invent most minimalistic social sharing platform: https://www.echowaves.com/

The most minimalistic app I've ever came up with https://www.echowaves.com/chimingclock -- it's only about 100 lines of code, 1 screen, no customizations, but I still think of it as very useful app. Of course, there is a lot of complexity that went behind the scenes building it. It took me almost a week to find the right combination of those 100 lines to make it work -- simple is not easy.

If you are as passionate about eliminating complexity in our lives (read in software we build every day), and if you've ever created something that just bare bones simple, share in comments about your experiences.

Turning old Tablet into Chiming Clock, or why do we need more clock apps?

Dmitry Amelchenko — Tue, 07 Mar 2023 16:04:12 +0000

Little bit of history

I'm a computer guy. I like to know my time exactly down to the second.

And, I'm also an engineer, and I love elegant mechanical things that simply work without any electricity.

I've had this clock for over 20 years. Every week I had to rewind it with a key, which I didn't mind doing all these years. I rewinded the clock about 1000 times (52 weeks * 20 years = 1040).

The chimes every 15 minutes were loud and clear, but everyone in the house hardly noticed it.

Eventually the spring started to wear off. So, every time after rewinding, I had to set the time couple of minutes ahead. By the middle of the week the clock would show correct time. And right before the next cycle, they would be 5 minutes late.

Currently, due to wear and tear the clock looses more than 15 minutes per week, I finally had to make a hard decision and stop rewinding it.

This is sad -- all over sudden, something was missing. Hearing the chimes every 15 minutes (although the time was never precise) made the house alive.

I had to do something about it -- I'm an engineer, I like solving challenges like this one.

Problem definition

So, why can't we have the best of both worlds -- the precise time and good old Westminster chimes? It turns out we can!

The mechanical clock may break one day. But there always will be some old tablet laying around which no one wants to use, because it's couple of versions old.

I happened to have exactly that -- the old android tablet which was collecting dust in a drawer.

The first thing I tried, I looked for applications on the app store. Who knows, perhaps someone has already built something that will work for my taste. Quickly I was disappointed. The solutions I found were a lot more complex than necessary. They all had lots of customizations. They all were mostly rather big and complex. And non of them offered the chimes I wanted.

I'm a true believer in simplicity when it comes down to engineering solutions. Simple things tend to last longer.

So, I have to build something myself, just because the existing solutions were a way too complicated, still didn't offer exactly what I wanted, and just because I can.

I want my new digital clock to behave as close as possible to my mechanical clock, with one exception -- they must show precise time.

It should work out of the box, no customizations. Think of it this way -- you bring the clock home, you open the box, you wind it up for the first time, you set the correct time, and that's it -- it just works. You never had to customize the mechanical clock, yet, some how no one complained back then. It's really hard for me to understand this obsession with customization.

If you don't like my default options you can do one of 3 things:

Don't use it, find an alternative. The stores back then offered variety of colors, sizes, shapes, quality, price range and brands. The app stores today most likely will have something that matches your desires as well.
Reach out to me with suggestions. If I like your idea -- I may add it to the next version of the application --> dmitry@echowaves.com
Make customizations yourself. The code is opensource --> https://github.com/echowaves/chimingClock . You can submit a pull request and, if it does not make the original software more complicated than it should be, I will merge it in. Or you can clone the repo and go wild.

Here are the customizations and features the application will not support:

Only supports landscape (I want my digits to occupy all available space on the screen).
Only one color scheme.
Only one type of font.
No support for military time. Not even showing "am/pm".
No support for seconds.
No support for calendar features.
No alarm, no timer.
No support for dimming (can be done at the device level).
No support for adjusting volume sound (can be done at the device level).
No support for different types of chimes -- only Westminster.
No support for weather updates.

The mechanical clock didn't have any of these customizations and they worked great. If you really want to change any of these defaults -- the code is open source.

The solution

Here is what I ended up building:

The clock is a decent size, visible from every corner of the living room, the proportions are nicely balanced. The wire sticking from the side is a little annoying, but hey, you can't expect everything to be perfect.

To make it stand, I had to glue a wooden cube to the back of the tablet with a piece of two sided sticky tape.

And that's all. Nothing beats the feeling of satisfaction upon project completion.

Investing few hours of time over the weekend saved me from buying something off of Amazon, and filled my house again with wonderful Westminster chimes I was beginning to miss when my old mechanical clock was retired.

It was originally posted here https://www.echowaves.com/chimingclock
The mobile app can be downloaded here:

Android
iOS

And the source code