Smart Blogging: A Collaborative Effort with Your AI Partner

It can be tough to think of a programming project to showcase your coding skills and intellectual curiosity as well as your creativity. Basically, any first pet project you'll embark on has already been done before by thousands of other intrepid programmers and let's face it... it's probably been done better as well.

As someone who studied Artificial Intelligence extensively in college, and was thoroughly underwhelmed, I completely ignored all of the hullabaloo earlier last year. That all changed earlier this week, when I found myself bored and wanting to embark on a new project. Wanting to look for some fresh ideas, I decided to ask ChatGPT (on a whim) what it's thoughts were.

Some people's eyes may glaze over at the long and draw out answer provided, but this gave me a novel idea: how about I write a blogging platform with the help of ChatGPT? The blogging platform itself will be about my interactions with it, as well as a commentary about learnings and iterations about the blogging platform, the different technologies I'll be using, as well as learnings about ChatGPT itself. And I'll provide a link to the actual conversation itself to showcase as much of the process as possible. I asked it what it thought (and not to my surprise) it liked that idea.

After a bit of back and forth on the tech stack we'd be using, some basic starting tips, and me cutting down on the scope a bit, We landed on an MVP. Basically it would look something like this:

1. Back-end would be a standard RESTful API written in C# (a simple ASP.NET Core Web API project) with all of the fixin's. I'm pretty familiar with the .NET ecosystem, so getting up and running shouldn't be too terrible.
2. Entity Framework connecting to and generating a SQLite3 schema.
3. React.js frontend calling the aforementioned ASP.NET REST API.

I asked it for boilerplate code and got to work:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

[Authorize] // This attribute requires authentication for all actions in this controller
[ApiController]
[Route("api/posts")]
public class PostsController : ControllerBase
{
    [HttpGet]
    public IActionResult GetPosts()
    {
        // Implement logic to retrieve a list of all blog posts
        // Example: var posts = _postService.GetPosts();
        // return Ok(posts);
        return Ok();
    }

    [HttpGet]
    public IActionResult GetPosts()
    {
        // Implement logic to retrieve a list of all blog posts
        // Example: var posts = _postService.GetPosts();
        // return Ok(posts);
        return Ok();
    }

    [HttpGet("{id}")]
    public IActionResult GetPostById(int id)
    {
        // Implement logic to retrieve a specific blog post by ID
        // Example: var post = _postService.GetPostById(id);
        // if (post == null) return NotFound();
        // return Ok(post);
        return Ok();
    }

    [HttpPost]
    public IActionResult CreatePost([FromBody] PostDto postDto)
    {
        // Implement logic to create a new blog post
        // Example: var createdPost = _postService.CreatePost(postDto);
        // return CreatedAtAction(nameof(GetPostById), new { id = createdPost.Id }, createdPost);
        return Ok();
    }

    [HttpPut("{id}")]
    public IActionResult UpdatePost(int id, [FromBody] PostDto postDto)
    {
        // Implement logic to update an existing blog post by ID
        // Example: var updatedPost = _postService.UpdatePost(id, postDto);
        // if (updatedPost == null) return NotFound();
        // return Ok(updatedPost);
        return Ok();
    }

    [HttpDelete("{id}")]
    public IActionResult DeletePost(int id)
    {
        // Implement logic to delete a blog post by ID
        // Example: _postService.DeletePost(id);
        // return NoContent();
        return Ok();
    }
}

Now, as you know if you've ever written an API of any sort, you'll know that this is probably the easiest part. What's harder is building out all of your services, getting a bulletproof authorization/authentication scheme in place, enabling all of the correct middleware for all of your use cases, and battling silly package management issues that are nearly certain to come up. So we did that.

After enough prodding, it helped me resolve compatibility issues due to a mismatch between the versions of the .NET SDK, Entity Framework Core, and related tools:

dotnet ef migrations add InitialCreate --version 6.0.0
dotnet ef database update
dotnet ef database update -Migration InitialCreate

When running the Migration gave me an error, it suggested several fixes... one of which was the root cause (I was missing the DesignTimeDbContextFactory). It also gave a detailed explanation as why not having that in place will throw the particular exception I was getting.

public class DesignTimeDbContextFactory : IDesignTimeDbContextFactory<ApplicationDbContext>
{
    public ApplicationDbContext CreateDbContext(string[] args)
    {
        var optionsBuilder = new DbContextOptionsBuilder<ApplicationDbContext>();
        optionsBuilder.UseSqlServer("your_connection_string");

        return new ApplicationDbContext(optionsBuilder.Options);
    }
}

It also gave me the boilerplate I needed for the Startup.cs file:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.EntityFrameworkCore;
using YourNamespace.Models; // Replace with the actual namespace of your models
using YourNamespace.Services; // Replace with the actual namespace of your services

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        // Configure DbContext
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlite(Configuration.GetConnectionString("DefaultConnection")));

        // Add services
        services.AddScoped<IPostService, PostService>(); // Replace with your actual service
        // Add other services as needed

        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            // Add production-specific configurations here
            app.UseExceptionHandler("/Home/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

This went on for quite a bit. We had a bit of a back and forth on why my SignInManager class wasn't actually signing in anyone, how to properly store secrets (in environment variables... duh), how to debug an entity framework misconfiguration, and how to properly create and use a JWT token. Being a .NET developer for almost 12 years, I kind of already knew the answer to a lot of these questions, but asked it them anyway. I'm pleasantly surprised at how quickly we were able to arrive at resolutions to these problems.

Key takeaways:

1. ChatGPT is extraordinarily good at being a sounding board of ideas. It can suggest entire feature sets, break down your projects into actionable steps, and really get you to hit the ground running. Just remember to reign it in.
2. It's incredible for debugging common problems and generating boilerplate, particularly when you're using well-documented and well-known programming libraries and frameworks.
3. It can and will give you buggy and incomplete code. And it since the training cut-off for ChatGPT 3.5 was in January 2022, it has an incomplete view of the world and may suggest obsolete solutions and old library code.
4. We're not getting replaced by AI anytime soon. It's a great tool that will turbocharge the productivity of anyone that will adopt them, but to suggest that it will eclipse us is absurd to me.

You can view the full chat here

The public Github repo for my work in progress can be found here

Note: the blog is absolutely nowhere near complete. For now, this blog post (and likely many future blog posts) will be powered by Ghost.