DEV Community: Patrick Wright

Use Code Generation To Advance Your Career

Patrick Wright — Tue, 10 Jun 2025 15:29:03 +0000

Opening Story

This post will detail one example of how I have used code generation to advance my career. While working for a large government contractor the team was looking for a software solution for tracking server configurations. We wanted to know what applications were installed on the servers and what versions of the applications were installed. We also wanted information on some applications that were xcopy deployed on the servers. We also needed information about the patches installed on Oracle instances. After listening to a vendor's presentation about their solution to our problem on a Friday afternoon I realized that I could build a 90% solution over the weekend.

My Solution

Retrieve the Server Configuration Information

I started with a database schema to hold the data I needed to produce the reports that are required. I wrote a .Net console application that queried Windows Management Instrumentation (WMI) to get a list of installed programs. From the .Net program I was able to call OPatch to get the info I needed from Oracle. I just checked for the existence of files to verify that our xcopy deployed tools were present. I now had all of the info I needed to put in the database and the database schema.

Generate a Web Application to View Server Configuration Information

At this point in my career I had created a database driven code generator that I used to generate code for me when working on database projects. I used to sell a code generator commercially. Depending on where I was working at the time I would use the one I used to sell or I would create one to use at work. In this case I created one to use at work and I had templates that would generate a CRUD application using ASP.Net. The next step was to point my code generator at my new schema and had a working application that would display data for my new database. I used the business and data tiers from the generated code in my console application to write the queried information to the database.

Modify the Generated Web Application

With the data in the database I needed to provide the users a way to see the information in the format they wanted. They needed more than data entry pages and views of single records. I added a few pages to the web app to allow users to view server configuration information over time by server and report on it. I packaged up the console app to make it easy to deploy. The application was installed by copying it to a server, updating a json config file and setting up a scheduled task to run the program. The scheduled task would fire off the program, the program would get the server configuration information and write it to the database and users could view the information from the web application.

The following Monday I demoed the application and it was very well received. We deployed it and used it for years.

From Manual to Automated

Code generation is a game-changer because it replaces repetitive, error-prone manual work with automation. Before I embraced it, I spent countless hours writing boilerplate code for APIs, data models, and configuration files. Each line had to be carefully crafted, tested, and maintained. And despite my best efforts, human error was inevitable.

With code generation, those days are behind me. Instead of writing the same code repeatedly, I create templates and scripts that generate it automatically. Not only does this save an incredible amount of time, but it also ensures consistency and reduces the likelihood of bugs. For example, instead of manually writing API backends for different services, I now use code generation to generate the CRUD endpoints in seconds. I also generate the units tests for the generated code. The team can now focus their time on business rules and adding business value.

Automation also frees up developers to focus on more valuable work—solving complex problems, designing better architectures, and improving performance. The more we automate, the more we can shift our efforts toward innovation rather than repetition.

The Career Boost

Mastering code generation doesn't just save time—it makes you invaluable to your team and organization. When I introduced automated code generation to my workflow, I quickly became the go-to person for improving development efficiency. My team started relying on me to find ways to streamline our processes, and before long, my reputation as a productivity booster spread.

Employers and managers love developers who can deliver results faster and more reliably. Code generation skills set you apart as someone who thinks critically about efficiency and scalability. It's not just about writing code—it's about writing less code while achieving more.

Because of my expertise in automation, I've had opportunities to work on high-impact projects, lead process improvements, and even mentor others in adopting these techniques. This has led to promotions, salary increases, and a stronger professional network. The ability to automate tedious tasks is a superpower in the software development world.

Quick Wins

The best way to start with code generation is by tackling small, practical projects. Here are a few simple ways to get quick wins:

Generate Configuration Files: Writing JSON, YAML, or XML configuration files by hand is tedious. Use templates to generate them dynamically based on input parameters.
Automate Boilerplate Code: If you frequently write similar classes, functions, or API endpoints, create a script to generate them from a template.
Use OpenAPI for API Clients: Many modern APIs provide OpenAPI specifications. Tools like Swagger Codegen or OpenAPI Generator can create API clients for various programming languages automatically.
Scaffold Projects: Instead of setting up a new project manually every time, create a project generator that initializes everything with best practices already in place.
Leverage ORM Code Generators: Many ORMs (Object-Relational Mappers) support generating models from database schemas, reducing the need to write tedious data models by hand.
Leverage a code generator like Monstarillo to generate code from your database or ORM model.

Each of these projects builds confidence and demonstrates immediate value. Once you see the power of automation, you'll start looking for opportunities to apply it everywhere.

Conclusion

Automation isn't just a buzzword—it's a career accelerator. By mastering code generation, you can eliminate repetitive work, reduce errors, and become an indispensable asset to any team. Whether you start with simple tasks like generating configuration files or build full-fledged automation tools, the impact is undeniable.

Looking back, that weekend project wasn't just about saving time—it was about transforming my approach to software development. Today, I write less code while achieving more, and my career has taken off because of it. If you're a developer looking to level up, start exploring code generation. It might just be your secret weapon for success.

Stop Writing Docs, Start Generating Them: How I Document My Code in Minutes with Syntax Scribe

Patrick Wright — Tue, 10 Jun 2025 15:09:32 +0000

We've all been there. You've built an amazing TypeScript project, spent weeks perfecting the code, and then... you need to document it. 😅

The README sits there, mocking you with its emptiness. Your functions are clean, your types are perfect, but explaining what everything does? That's going to take hours.

What if I told you there's a tool that can analyze your entire codebase and generate beautiful, professional documentation in minutes? Let me introduce you to Syntax Scribe.

The Documentation Struggle is Real

Before we dive in, let's be honest about documentation:

✅ We know it's important
✅ We know our users (and future selves) need it
❌ We rarely have time to write it properly
❌ Keeping it updated is a nightmare
❌ Writing good docs is genuinely hard

I used to spend entire weekends writing documentation for client projects. Not anymore.

What is Syntax Scribe?

Syntax Scribe is a CLI tool that analyzes your TypeScript, JavaScript, Vue, and TSX files and automatically generates comprehensive documentation. But here's the kicker: it doesn't rely on comments in your code. It analyzes the actual structure and generates clean, readable docs.

Key Features That Won Me Over

🔍 Deep Code Analysis - Parses functions, interfaces, types, and their relationships

📚 MkDocs Integration - Creates professional documentation sites with Material theme

🔒 Privacy First - Everything happens locally on your machine

⚡ Zero Setup - Works out of the box with any TypeScript/JavaScript project

🎨 Beautiful Output - Clean, organized Markdown ready for GitHub or internal wikis

See It In Action

Here's what Syntax Scribe generated from a simple database utility file:

# 📄 `db.ts`

## 🧾 Summary
- **Functions**: 1
- **Classes**: 0  
- **Imports**: 4
- **Interfaces**: 0
- **Type Aliases**: 0

## 📦 Imports
| Name | Source |
|------|--------|
| `drizzle` | `drizzle-orm/neon-http` |
| `neon` | `@neondatabase/serverless` |
| `neonConfig` | `@neondatabase/serverless` |
| `H3Event` | `h3` |

## 🔧 Functions

### `getDb(event: H3Event): any`

<details>
<summary>Code</summary>

ts
export function getDb(event?: H3Event) {
if (!_db) {
// Get database URL from runtime config
const config = useRuntimeConfig();
if (!config.DATABASE_URL) {
throw new Error('DATABASE_URL is missing from environment variables');
}

// Create SQL connection
const sql = neon(config.DATABASE_URL);

// Create Drizzle instance
_db = drizzle(sql, { schema });
console.log('Database connection initialized');

}

return _db;
}

</details>

- **Parameters**: `event: H3Event`
- **Return Type**: `any`
- **Calls**: `useRuntimeConfig`, `neon`, `drizzle`, `console.log`

This is clean, organized, and tells you everything you need to know about the code. No comments required!

The 5-Minute Workflow

Here's how I generate docs for any project:

1. Install Syntax Scribe

npm install -g syntax-scribe

2. Generate Documentation

syntax-scribe docs document \
  -s "~/code/my-project" \
  -d "~/code/my-docs/docs" \
  -l your-license-key

3. Create MkDocs Site

syntax-scribe docs init \
  -d "~/code/my-docs" \
  -n "My Project Documentation" \
  -l your-license-key

4. Generate Navigation

syntax-scribe docs nav \
  -d "~/code/my-docs" \
  -l your-license-key

5. Preview Locally

syntax-scribe docs serve -d "~/code/my-docs" -l your-license-key

Boom! Professional documentation site running at localhost:8000.

Real-World Impact

Since using Syntax Scribe, I've:

Reduced documentation time by 90% - From hours to minutes
Improved client handoffs - Clients get professional docs with every project
Increased team adoption - Teammates actually maintain docs when it's this easy
Better code quality - The analysis helps me spot inconsistencies

Perfect for Different Use Cases

Freelancers & Agencies: Impress clients with professional documentation

Open Source: Generate comprehensive READMEs and wikis

Enterprise: Document internal APIs and component libraries

Personal Projects: Keep future-you from hating present-you

The GitHub Pages Bonus

Want to host your docs for free? Syntax Scribe integrates perfectly with GitHub Pages. The generated MkDocs sites deploy seamlessly with GitHub Actions.

Here's a quick GitHub Actions workflow that auto-deploys your docs:

name: Deploy MkDocs to GitHub Pages

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.x'
      - run: |
          pip install mkdocs mkdocs-material
          mkdocs build --clean
      - uses: actions/deploy-pages@v4

Push to main, and your docs are live at username.github.io/repo-name.

Why This Matters

Good documentation isn't just about helping others—it's about:

Reducing support burden - Better docs = fewer questions
Faster onboarding - New team members get up to speed quickly
Professional credibility - Quality docs signal quality code
Future-proofing - Your future self will thank you

Try It Yourself

Syntax Scribe offers a 14-day free trial, and the basic documentation generation works on any TypeScript/JavaScript project.

Get started: Visit syntaxscribe.com or install directly:

npm install -g syntax-scribe

Final Thoughts

I'll be honest—I was skeptical about automated documentation tools. But Syntax Scribe changed my mind. It doesn't try to be magical; it just does one thing really well: analyzing your code and presenting it clearly.

The time savings alone are worth it, but the quality of the output genuinely impresses me. Plus, knowing that everything runs locally gives me peace of mind for client projects.

If you're drowning in documentation debt or want to impress clients with professional deliverables, give Syntax Scribe a try. Your future self (and your users) will thank you.

Have you tried automated documentation tools? What's your biggest documentation challenge? Let me know in the comments!

Generate a REST API Using Java and Spring Boot for your Postgres database

Patrick Wright — Wed, 08 Jan 2025 16:23:30 +0000

This tutorial will show you how you can generate a Java API for your Postgres database using monstarillo. The API will use Spring Boot and Springdoc to document it. The API will perform CRUD operations on the tables you run it against. Unit tests will also be generated for the API.
To follow along with this tutorial you will need:

monstarillo installed.
A Postgres database – I will be using the chinhook database. Set up the Chinhook Sample Postgres Database in Docker
Java installed
A Java IDE – I will be using InteliJ
Git

The first step will be to get the templates that we will be using to generate our API. To do so clone the repo shared-templates. The templates we will be using are in the java-api folder.
Tell Monstarillo where to put the Generated code
Next you will need to decide where you want the generated code to be placed. I will be running Monstarillo through Docker. I will be exposing the directory ~/shared-volume to the docker image running Monstarillo. The shared-templates folder created by cloning the repo is in the ~/shared-volume folder. I will be generating code in ~/shared-volume/code-gen-output. Monstarillo will create the code-gen-output folder when it generates the code.

Modify the templates.json file
Monstarillo uses a json file to tell it which templates to run, how to run them, and what to name the files it generates and where to put them. We will be modifying the file java-api/postgres/templates.json. The templates array in the templates.json file tells Monstarillo which templates to run, what to name the files it creates and where to put them. The tags array in the templates.json file defines some “tags” that are used in templates and/or the templates.json. For example the PackagePath is used numerous time in the templates.json file. The PackagePath is used in a number of templates, the tag allows us to define it once. To run the templates you will need to modify TemplateRoot and OutputPath tags in the tags array.

*TemplateRoot *– Template root needs to point to the java-api folder in the repository that you cloned.
*OutputPath *– Output path need to point to the folder that you want Monstarillo to put the files it generates in. Monstarillo will create the folder if it does not already exist.
*PackageBase *– Used to set the package in classes
*ArtifactId *– Used in the generated POM.xml
*GroupId *– Used in the generated POM.xml
*ApplicationClassName *– Used as the name of the main class of the generated application
*ModelPropertySurrondString *– Used in the template that generates the models for the application. This is useful if your column names are camel cased.

I am running Monstarillo in docker so I will set the tags to:

{
   "tagName": "TemplateRoot",
   "value": "/usr/local/monstarillo/shared-templates/java-api"
},
{
   "tagName": "OutputPath",
   "value": "/usr/local/monstarillo/code-gen-output/java-01"
}

If I was running Monstarillo locally I would set the tags to:

{
   "tagName": "TemplateRoot",
   "value": "/home/patrick/code/patrick-templates/java-api"
},
{
   "tagName": "OutputPath",
   "value": "/home/patrick/code-gen-output/java-01"
}

Run Monstarillo to Generate The Code
Next we will build the command to run Monstarillo to generate the code for us. We will need to tell Monstarillo that we are using a Postgres database and provide the connection information. We will also need to tell Monstarillo which templates to run by passing the location of the templates.json file we set up earlier.

To run Monstarillo in docker our command will look similar to:

docker run --volume=/mnt/c/code:/usr/local/monstarillo \
--network=host \
monstarillo/monstarillo:latest postgres \
--t /usr/local/monstarillo/shared-templates/java-api/postgres/templates.json  \
--u postgres \
--p <Your Database Password> \
--db "chinhook-db" \
--host "localhost" \
--schema "public"
In this command I am mounting /mnt/c/code to the docker image as /usr/local/monstarillo that is running monstarillo. My shared-templates folder is at /mnt/c/code/shared-templates and will be generating code to /mnt/c/code/code-gen-output/java-01

If I were running Monstarillo locally my command would be:

monstarillo postgres \
--t /home/patrick/code/patricks-monstarillo-templates/java-api/templates.json  \
--u postgres \
--p <Your Database Password>\
--db "chinhook-db" \
--host "localhost" \
--schema "public"

When you run the command your output will be similar to:

Notice that Monstarillo prints out each table name and that it runs against. You may be able to use this information to troubleshoot errors in your command.

View Your Generated Code
Next you can view your code by opening the output directory you chose in your IDE of choice.

Next you will need to modify the application.properties file in your generated code to update your database connection information. The file can be found at src/main/resources/application.properties

In IntelliJ I will open the PersistApi class in the IDE and run it.

My new API is running and I can test it. I will use Postman. I can access the album controller at http://localhost:8080/album

You can also surf to http://localhost:8080/swagger-ui/index.html to see the generated OpenAPI definition for the generated code.

Notice the unit tests that have been generated in src/java/com.monstarillo.persist_api

Let me know what you think in the comments

Generate a REST API Using Java and Spring Boot for your Postgres database

Patrick Wright — Mon, 06 Jan 2025 13:50:10 +0000

monstarillo installed.
A Postgres database – I will be using the chinhook database. Set up the Chinhook Sample Postgres Database in Docker
Java installed
A Java IDE – I will be using InteliJ
Git

TemplateRoot– Template root needs to point to the java-api folder in the repository that you cloned.
OutputPath– Output path need to point to the folder that you want Monstarillo to put the files it generates in. Monstarillo will create the folder if it does not already exist.
PackageBase– Used to set the package in classes
ArtifactId– Used in the generated POM.xml
GroupId– Used in the generated POM.xml
ApplicationClassName– Used as the name of the main class of the generated application
ModelPropertySurrondString– Used in the template that generates the models for the application. This is useful if your column names are camel cased.

I am running Monstarillo in docker so I will set the tags to:

{
   "tagName": "TemplateRoot",
   "value": "/usr/local/monstarillo/shared-templates/java-api"
},
{
   "tagName": "OutputPath",
   "value": "/usr/local/monstarillo/code-gen-output/java-01"
}

If I was running Monstarillo locally I would set the tags to:

{
   "tagName": "TemplateRoot",
   "value": "/home/patrick/code/patrick-templates/java-api"
},
{
   "tagName": "OutputPath",
   "value": "/home/patrick/code-gen-output/java-01"
}

To run Monstarillo in docker our command will look similar to:

docker run --volume=/mnt/c/code:/usr/local/monstarillo \
--network=host \
monstarillo/monstarillo:latest postgres \
--t /usr/local/monstarillo/shared-templates/java-api/postgres/templates.json  \
--u postgres \
--p <Your Database Password> \
--db "chinhook-db" \
--host "localhost" \
--schema "public"
In this command I am mounting /mnt/c/code to the docker image as /usr/local/monstarillo that is running monstarillo. My shared-templates folder is at /mnt/c/code/shared-templates and will be generating code to /mnt/c/code/code-gen-output/java-01

If I were running Monstarillo locally my command would be:

monstarillo postgres \
--t /home/patrick/code/patricks-monstarillo-templates/java-api/templates.json  \
--u postgres \
--p <Your Database Password>\
--db "chinhook-db" \
--host "localhost" \
--schema "public"

When you run the command your output will be similar to:

Notice that Monstarillo prints out each table name and that it runs against. You may be able to use this information to troubleshoot errors in your command.

View Your Generated Code
Next you can view your code by opening the output directory you chose in your IDE of choice.

Next you will need to modify the application.properties file in your generated code to update your database connection information. The file can be found at src/main/resources/application.properties

In IntelliJ I will open the PersistApi class in the IDE and run it.

My new API is running and I can test it. I will use Postman. I can access the album controller at http://localhost:8080/album

You can also surf to http://localhost:8080/swagger-ui/index.html to see the generated OpenAPI definition for the generated code.

Notice the unit tests that have been generated in src/java/com.monstarillo.persist_api

Let me know what you think in the comments