DEV Community: Ayomide Onibokun

The Art of Agentic Rules: How to Architect a Project-Aware AI

Ayomide Onibokun — Tue, 23 Dec 2025 18:51:34 +0000

In the era of "Agentic IDEs" like Cursor, Windsurf, and Antigravity, the role of the developer is shifting from writing code to architecting context. Most developers treat these tools like smarter autocomplete, dropping a prompt and hoping for the best. This approach fails because code generation is only as good as the constraints you place upon it.

This article shows you how to move from generic prompting to building a Project-Aware Agent using structured rule files. We synthesize lessons from open-source projects like Coolify and Supabase to provide you with a universal framework for defining your own agentic constraints.

The Core Philosophy: Don't Just Guide, Constrain

The biggest mistake developers make with AI context is assuming "more is better." They dump their entire documentation into the chat.

This is wrong.

AI models suffer from "context pollution." If you feed an agent React documentation, generic TypeScript guides, and your entire legacy codebase, it gets confused. It might suggest a React 16 pattern for a React 18 project, or use a deprecated library function because it saw it in an old file.

Effective agentic rules follow two key philosophies:

1. Context-Aware Loading (The "Sniper" Approach)

Don't load every rule for every file. Use glob matching to target specific instructions.

Good example:

Database rules only load when touching schema.prisma or backend/db/*.ts.
Frontend component rules only activate for src/components/**/*.tsx.

Bad example:
Loading your entire "Best Practices" document into every chat session, regardless of whether you are writing SQL or CSS.

2. The "Negation" Strategy (Anti-Patterns)

It is often more effective to tell an AI what NOT to do than what to do. Explicitly banning patterns reduces the search space for the model, forcing it toward the correct solution.

Key Strategies From Coolify and Supabase

Analyzing frameworks like Coolify and Supabase reveals a standardized approach to agentic configuration.

1. Centralized Documentation Architecture

Instead of scattering instructions in prompts, maintain a single source of truth.

Coolify uses a .ai/ directory with topic-specific markdown files (e.g., testing.md, laravel.md).
Supabase uses .mdc files with structured frontmatter metadata.

2. Context-Aware Rule Application

Supabase excels at this. They use frontmatter to define exactly when a rule applies:

---
description: "Standards for writing database functions"
globs: "supabase/migrations/*.sql"
alwaysApply: false
---

This ensures the agent only "thinks" about database security when it's actually writing SQL.

3. Explicit Anti-Pattern Prevention

Supabase's rules often include sections that visually distinguish critical constraints:

🚨 CRITICAL INSTRUCTIONS
❌ NEVER generate this code pattern...
✅ CORRECT implementation...

This visual distinction helps the model prioritize safety constraints over creative generation.

Case Study: From Generic To Intelligent

How does this evolution look in practice? Let's trace the journey of a hypothetical project, "Project X".

Phase 1: The Generic Agent (The "Junior")

Setup: No custom rules.
Behavior: The agent writes standard, syntactically correct code.
Problem: It uses any types, imports generic libraries (like lodash) that you don't use, and writes tests that don't match your mocking strategy. You have to rewrite 30% of its output.

Phase 2: The Rules-Based Agent (The "Mid-Level")

Setup: Added .cursor/rules/typescript.md and .cursor/rules/testing.md.
Behavior: The agent now respects strict: true in TypeScript and uses your preferred testing library.
Problem: It still makes architectural mistakes. It might import a server-side module into a client component or create circular dependencies.

Phase 3: The Project-Aware Agent (The "Senior")

Setup: Added rules for Architecture, Workflow, and Tech Stack Constraints.
- Tech Stack: "NEVER use OpenAI SDK < 4.0.0".
- Architecture: "Modules in shared/ can NEVER import from features/".
- Workflow: "When adding a new API provider, you MUST follow these 5 steps..."
Behavior: The agent now acts as a guardian of your codebase. It refuses to write code that violates architectural boundaries and self-corrects if it accidentally uses a forbidden pattern.

Practical Checklist: Building Your Rules

Ready to verify if your agentic setup is mature? Use this checklist to build your own "Team Brain."

1. The Directory Structure

Create a dedicated folder (e.g., .cursor/rules or .agent/rules) to house your brain.

.agent/rules/
├── stack-versions.md       # "We use Next.js 14, Tailwind 3.4..."
├── architecture.md         # "Frontend cannot talk to DB directly..."
├── anti-patterns.md        # "Never use 'any', never use 'console.log'..."
└── workflows/
    └── add-feature.md      # "Step 1: Create type, Step 2: Create component..."

2. The Tech Stack Authority

Create a file that lists your exact versions.

Why it matters: This prevents "hallucinated upgrades" where the AI uses features from a version you don't have.

Content Example: "We use Node 18 (ESM). We use React Query v5 (not v4)."

3. The "Gotchas" File

Every project has weird bugs or constraints. Document these as explicitly as possible.

Format: "⚠️ WARNING: When using DatePicker, ALWAYS provide timeZone prop."

4. Workflow Automation

Don't just define code styles; define processes.

Example: "To add a new endpoint: 1. Define Zod schema. 2. Create handler. 3. Register in router. 4. Write integration test."

Conclusion: Start With One Rule

The difference between a frustrating AI experience and a productive one often comes down to clear documentation. By treating agentic rules as a versioned, structured, and maintained part of your codebase, you transform your IDE into a project-aware assistant that strictly follows your team's standards.

Don't try to document everything at once. Start small. Add one rule today that stops the AI from making that one mistake it makes every single time, and you will see immediate improvements in your workflow.

Automate Content Quality with VectorLint GitHub Action

Ayomide Onibokun — Sat, 20 Dec 2025 09:02:46 +0000

Content reviews can be time-consuming for technical writers, especially when working with new writers who are just adjusting to your style guide, resulting in repetitive comments that are often the same. These repetitive checks take time away from content strategy and information architecture.

VectorLint aims to solve this by automating your content reviews using LLMs to evaluate and score your content. It uses LLM-as-a-Judge to catch content quality issues that typically require human judgment.

Instead of you acting as the style police, VectorLint runs AI-powered quality checks directly in your Pull Requests. It catches issues defined by your style rules before you even open the review. Writers get immediate feedback, and reviewers can do what they do best, which is providing actionable feedback and helping writers improve their content.

This guide walks you through setting up VectorLint, configuring AI providers, and customizing rules for your content types.

Quick Integration

Add VectorLint to your repository with this workflow:

name: VectorLint

on:
  pull_request:
    paths:
      - '**/*.md'
      - '**/*.mdx'

permissions:
  contents: read
  pull-requests: write
  checks: write

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run VectorLint
        uses: TRocket-Labs/vectorlint-action@v1
        with:
          llm_provider: anthropic
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          reporter: github-pr-check
          filter_mode: added
          fail_on_error: false

For more details on configuration check out the VectorLint Action Repo:

GitHub: TRocket-Labs/vectorlint-action

Setup Guide

Want to see VectorLint in action before setting it up? Check out this working example:

👉 ayo6706/vectorlint - Fork it, open a PR with markdown changes, and watch VectorLint review your content.

Before You Start

You'll need:

An API key from OpenAI, Anthropic, Google Gemini, or Azure OpenAI
The API key stored in GitHub Secrets:
- Go to Settings → Secrets and variables → Actions
- Click "New repository secret"
- Name it ANTHROPIC_API_KEY (or match your provider)
- Save it

Quick Start (5 Minutes)

Step 1: Create your rules folder

Create .github/rules/MyRules/ai-pattern-evaluator.md:

---
specVersion: 1.0.0
type: subjective

severity: warning
name: AI Pattern Detector
id: AIPatterns
target:
  regex: '[\s\S]+'
  flags: 'mu'
  group: 0
  required: true
  suggestion: Content must not be empty for AI pattern detection.
criteria:
  - name: Language Authenticity
    id: LanguageAuthenticity
    weight: 20
    severity: error
  - name: Structural Naturalness
    id: StructuralNaturalness
    weight: 20
    severity: warning
  - name: Transitional Flow
    id: TransitionalFlow
    weight: 20
    severity: warning
  - name: Emphatic Contrast Patterns
    id: EmphaticContrastPatterns
    weight: 20
    severity: warning
  - name: Opening Authenticity
    id: OpeningAuthenticity
    weight: 20
    severity: warning
---

You are an expert content evaluator specializing in identifying AI-generated writing patterns. Your goal is to detect specific AI patterns in written content and provide targeted improvement suggestions to make the writing more natural and human-like.

## INSTRUCTION
Evaluate the provided content against 5 key criteria that identify common AI writing patterns. For each criterion, count the number of pattern violations, assign a score based on frequency, and provide specific examples with improvement suggestions. Calculate weighted scores and provide a final humanness score out of 100.

## EVALUATION STEPS
1. Read the entire content carefully
2. For each criterion, systematically scan for the specific patterns listed
3. Count each occurrence of the patterns
4. Note the exact phrases/structures that match the patterns
5. Assign scores based on violation frequency
6. Calculate weighted scores
7. Provide specific examples and suggested rewrites for all violations found

## CONTEXT BANK

### What Counts as a Violation?
- **AI Buzzwords:** Any use of the 30 listed buzzwords (even if used appropriately)
- **Overly Formal Phrases:** Unnecessarily sophisticated language that sounds unnatural in context
- **Overused Action Verbs:** Repetitive use of the same "impressive" verbs (e.g., using "leverage" multiple times)
- **Bullet Points with Bold Titles:** Formatting pattern of **Bold Title:** followed by explanation
- **Consecutive Simple Sentences:** 3+ simple sentences in a row with same structure
- **Rule of Three:** Grouping items in threes repeatedly (not occasional use, but overuse)
- **Formulaic Transitions:** Starting sentences/paragraphs with formal transitions
- **Excessive Em Dashes:** Using em dashes (—) more than sparingly for dramatic effect
- **From-To Structures:** Repetitive "from X to Y" constructions
- **Emphatic Contrasts:** "Not just/only...but (also)" or "didn't...but" patterns
- **Generic Openings:** Starting with broad, obvious statements about "today's world," "modern era," etc.

### Counting Guidelines
- Count each distinct occurrence
- If the same buzzword appears 3 times, that's 3 violations
- Multiple patterns in one sentence count separately
- Only count clear, unambiguous pattern matches

## RUBRIC

# 1. Language Authenticity <weight=20>
Detects unnatural word choices that signal AI generation: buzzwords, overly formal phrases, and overused action verbs.

**Patterns to identify:**
- **AI Buzzwords (30 total):** elevate, delve, explore (overused), leverage, enhance, utilize, foster, propel, optimize, catalyze, disrupt, synergize, ensure, illuminate, cultivate, prowess, harness, turbocharge, spearheaded, energize, navigate, deploy, elucidate, galvanize, reimagine, streamline, unlock, seamless, "in the world of", "game-changer"
- **Overly Formal Phrases:** "delve into," "navigate the landscape," "meticulously," "realm," etc.
- **Overused Action Verbs:** Repetitive use of impressive verbs like "foster/fostering," "leverage/leveraging"

### Excellent <score=4>
0 violations detected. Language is natural and conversational.

### Good <score=3>
1-2 violations detected. Occasional AI-like language but mostly natural.

### Fair <score=2>
3-4 violations detected. Noticeable AI patterns affecting authenticity.

### Poor <score=1>
5+ violations detected. Heavy use of AI buzzwords and unnatural phrasing.

---

# 2. Structural Naturalness <weight=20>
Detects robotic organization patterns: excessive formatting, repetitive sentence structures, and rule of three overuse.

**Patterns to identify:**
- **Overly Structured Format:** Bullet points with bold titles (e.g., **Innovation**: text...), numbered body paragraphs inappropriately
- **Repetitive Sentence Structures:** 3+ consecutive simple sentences, repetitive participial phrases (X, doing Y, doing Z)
- **Rule of Three Overuse:** Constantly grouping things in threes (triple adjectives, triple phrases)

### Excellent <score=4>
0 violations detected. Structure varies naturally throughout.

### Good <score=3>
1-2 violations detected. Occasional structural patterns but mostly varied.

### Fair <score=2>
3-4 violations detected. Noticeable repetitive structure affecting flow.

### Poor <score=1>
5+ violations detected. Heavy formulaic structure throughout.

---

# 3. Transitional Flow <weight=20>
Detects mechanical connection patterns: formulaic transitions, excessive em dashes, and from-to structures.

**Patterns to identify:**
- **Formulaic Transitions:** "Moreover," "Furthermore," "It is important to note," "Additionally" starting sentences/paragraphs
- **Excessive Em Dash Usage:** Overusing em dashes (—) for pauses or explanations
- **From-To Structures:** Repetitive "from X to Y" constructions

### Excellent <score=4>
0 violations detected. Transitions flow naturally and vary.

### Good <score=3>
1-2 violations detected. Occasional formulaic transitions but mostly natural.

### Fair <score=2>
3-4 violations detected. Noticeable mechanical transition patterns.

### Poor <score=1>
5+ violations detected. Heavy reliance on formulaic connectors.

---

# 4. Emphatic Contrast Patterns <weight=20>
Detects overuse of emphatic negation structures that signal AI generation.

**Patterns to identify:**
- **Emphatic Negations:** "Not only...but also," "It is not just about X, it's about Y," "didn't...but" structures

### Excellent <score=4>
0 violations detected. Contrasts expressed naturally.

### Good <score=3>
1-2 violations detected. Occasional emphatic contrast but acceptable.

### Fair <score=2>
3-4 violations detected. Noticeable pattern of emphatic negations.

### Poor <score=1>
5+ violations detected. Heavy reliance on "not just...but" formulas.

---

# 5. Opening Authenticity <weight=20>
Detects generic, overly broad opening statements typical of AI writing.

**Patterns to identify:**
- **Generic Openings:** "In today's rapidly evolving world," "In the modern era," "In the digital age," "In today's landscape," etc.

### Excellent <score=4>
0 violations detected. Opening is specific and engaging.

### Good <score=3>
1-2 violations detected. Minor generic elements in opening.

### Fair <score=2>
3-4 violations detected. Multiple generic statements in opening.

### Poor <score=1>
5+ violations detected. Opening heavily relies on generic statements.

---

## OUTPUT FORMAT

Provide your evaluation in the following structure:

### CRITERION 1: LANGUAGE AUTHENTICITY
**Raw Score:** [1-4]  
**Weighted Score:** [Raw Score ÷ 4 × 20 = X/20]  
**Violations Found:** [number]

**Examples:**
- "[exact phrase from content]" → Suggested revision: "[improved version]"
- "[exact phrase from content]" → Suggested revision: "[improved version]"

[Continue for all violations]

---

### CRITERION 2: STRUCTURAL NATURALNESS
**Raw Score:** [1-4]  
**Weighted Score:** [Raw Score ÷ 4 × 20 = X/20]  
**Violations Found:** [number]

**Examples:**
- "[exact phrase/structure from content]" → Suggested revision: "[improved version]"

[Continue for all violations]

---

### CRITERION 3: TRANSITIONAL FLOW
**Raw Score:** [1-4]  
**Weighted Score:** [Raw Score ÷ 4 × 20 = X/20]  
**Violations Found:** [number]

**Examples:**
- "[exact phrase from content]" → Suggested revision: "[improved version]"

[Continue for all violations]

---

### CRITERION 4: EMPHATIC CONTRAST PATTERNS
**Raw Score:** [1-4]  
**Weighted Score:** [Raw Score ÷ 4 × 20 = X/20]  
**Violations Found:** [number]

**Examples:**
- "[exact phrase from content]" → Suggested revision: "[improved version]"

[Continue for all violations]

---

### CRITERION 5: OPENING AUTHENTICITY
**Raw Score:** [1-4]  
**Weighted Score:** [Raw Score ÷ 4 × 20 = X/20]  
**Violations Found:** [number]

**Examples:**
- "[exact phrase from content]" → Suggested revision: "[improved version]"

[Continue for all violations]

---

## FINAL SCORE CALCULATION

**Total Weighted Score:** [Sum of all weighted scores] / 100

**Calculation:**
- Language Authenticity: [X/20]
- Structural Naturalness: [X/20]
- Transitional Flow: [X/20]
- Emphatic Contrast Patterns: [X/20]
- Opening Authenticity: [X/20]
- **TOTAL: [X/100]**

---

## OVERALL ASSESSMENT

**Humanness Level:** [Excellent (90-100) / Good (75-89) / Fair (60-74) / Needs Improvement (<60)]

**Summary:** [2-3 sentence overview of the content's AI pattern profile]

**Priority Improvements:** [List the top 2-3 most critical patterns to address first]

Step 2: Create your config

Create vectorlint.ini in your repo root:

RulesPath=.github/rules
Concurrency=4
DefaultSeverity=warning

[**/*.md]
RunRules=MyRules

Step 3: Add the GitHub Action

Create .github/workflows/vectorlint.yml with the YAML above.

Step 4: Test it

Commit everything and open a PR with markdown changes. VectorLint will review your content within 30-60 seconds.

Note: You can change triggers to push or other events as needed.

Configuration Options

Choose Your AI Provider

Anthropic (Claude)

llm_provider: anthropic
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
anthropic_model: claude-sonnet-4-20250514

OpenAI

llm_provider: openai
openai_api_key: ${{ secrets.OPENAI_API_KEY }}
openai_model: gpt-4o
openai_temperature: '0.2'

Google Gemini

llm_provider: gemini
gemini_api_key: ${{ secrets.GEMINI_API_KEY }}
gemini_model: gemini-2.5-pro

Azure OpenAI

llm_provider: azure-openai
azure_openai_api_key: ${{ secrets.AZURE_OPENAI_API_KEY }}
azure_openai_endpoint: ${{ secrets.AZURE_OPENAI_ENDPOINT }}
azure_openai_deployment_name: my-deployment

Reporter Types

Type	What It Does
`github-pr-check`	Annotations in "Files Changed" tab (recommended)
`github-pr-review`	Comments on specific lines like a human reviewer
`github-check`	Pass/fail status only

Filter Modes

Choose your filter mode based on review scope requirements. added mode works for most teams because it focuses review effort on new content while avoiding noise from unchanged sections.

Mode	What Gets Checked	Best For
`added`	Only new/changed lines	Most projects
`diff_context`	Changed lines plus surrounding context	When changes affect flow
`file`	Entire changed files	New content that needs full review
`nofilter`	All files in PR	Major content overhauls

Enforcement Options

Advisory Mode (fail_on_error: false) - Shows suggestions, doesn't block merging

fail_on_error: false

Strict Mode (fail_on_error: true) - Blocks merges until issues fixed

fail_on_error: true
filter_mode: file

Start in advisory mode for your first month so writers learn the standards without friction. This approach reduces resistance to automated review while building trust in the system. Switch to strict mode once your team consistently addresses feedback and understands your quality standards.

Different Standards by Content Type

Blog posts can be casual. API docs must be precise. Use file patterns to apply different rule packs:

vectorlint.ini:

RulesPath=.github/rules
Concurrency=4
DefaultSeverity=warning

[blog/**/*.md]
RunRules=BlogRules

[docs/api/**/*.md]
RunRules=APIDocRules

Each rule pack (e.g., BlogRules, APIDocRules) is a folder of Markdown rule files in your RulesPath. Same workflow, context-aware enforcement.

Sample setup:

Check out a working example at ayo6706/vectorlint - it shows the complete configuration including vectorlint.ini and custom rules.

Creating custom rules:

Rules are Markdown files with YAML frontmatter.

👉 Learn how to create custom rules →

Check out VectorLint Action at GitHub Marketplace

Next Steps

Once you've configured VectorLint for your workflow, implement it gradually to build team confidence in the system.

Start with advisory mode and one simple rule. Once your team sees consistent feedback, expand your rule set.

Week 1: Run in advisory mode with a single style rule
Week 2: Add 2-3 more rules based on your most common feedback
Week 3-4: Monitor adoption and address any confusion about rule violations
Week 4-5: Enable strict mode to block merges on violations

Ready to try it? Fork the sample repo to see it in action, check out VectorLint on npm, or give it a star VectorLint, VectorLint Github action.

Node.js Essentials: Everything You Need to Know as a Software Developer

Ayomide Onibokun — Fri, 01 Dec 2023 22:10:12 +0000

What is Node.js, then?

Introduction:
Node.js is an open-source, cross-platform JavaScript runtime environment that operates outside the confines of a web browser. Powering this runtime is the V8 JavaScript engine, initially developed by Google in C++. Unlike the conventional use of JavaScript solely in browsers, V8 enables the execution of JavaScript code both within and beyond browser environments, making server-side scripting feasible.
The V8 engine translates JavaScript code directly into machine code, facilitating comprehension by computers. This compiled code is optimised for efficient execution, contributing to Node.js's impressive performance.

Model of Execution:
Node.js distinguishes itself from traditional multi-threaded approaches by employing a single-threaded execution model. JavaScript is by nature a single-threaded programme that can only use one CPU at a time; however, Node.js uses an event-driven architecture to support concurrent operations.
It's important to note that, despite being single-threaded, Node.js employs an event loop to handle asynchronous tasks, allowing it to efficiently manage multiple operations without blocking the execution of other tasks. This event-driven approach contributes to the scalability and responsiveness of Node.js applications.

Performance Considerations:
Node.js applications run in a single process, avoiding the creation of a new thread for each request. Although this single-threaded model is consistent with the nature of JavaScript, it can be viewed as a limitation when compared to languages such as Java, C++, or Golang, which support true multi-threading. In those languages, a single process can efficiently use all available CPUs on a machine, and threads are more lightweight, resulting in faster startup times and lower memory consumption.
To overcome this limitation, Node.js developers often resort to running multiple Node.js processes, each on a different port. Load balancers like NGINX or process managers like PM2 are employed to distribute incoming requests across these processes, ensuring efficient resource utilisation.

Concurrency in Node.js:
While Node.js operates within a single thread, it allows for concurrent operations through its event-driven architecture. This enables developers to handle multiple tasks simultaneously without creating additional threads. It's crucial to understand that this concurrency doesn't involve true multi-threading but rather a non-blocking approach, where events trigger asynchronous operations.

Simulating multithreading in Node.js:
Node.js provides a workaround for its single-threaded limitation by introducing the concept of forking. The fork method spawns child processes, essentially creating new instances of the V8 engine to run multiple worker processes. This enables Node.js to distribute operations across the various cores of the host machine.

In this example, multiple instances of worker.js are forked as child processes by main.js. Every worker process has the ability to run concurrently and independently. Message passing is used to communicate between the main process and the worker processes.
To run this example, run main.js with Node. The fork method in main.js creates separate instances of worker.js, allowing for parallel task execution across multiple CPU cores. This simulates a multithreading environment within the single-threaded Node.js runtime.

Asynchronous I/O in Node.js:
Node.js leverages asynchronous I/O primitives in its standard library, ensuring that JavaScript code remains non-blocking. This approach is crucial for handling I/O operations such as network requests, database access, or file system interactions. Rather than blocking the main thread while waiting for responses, Node.js resumes operations when the required data is available.

In the above example, the synchronous method readFileSync blocks the thread until the file is read, while the asynchronous method readFile allows other operations to proceed without waiting for the file read to complete.

Synchronous vs. Asynchronous Applications:
Synchronous applications can cause a poor user experience by blocking the user interface until a request is completed. In contrast, asynchronous applications allow users to continue interacting with the application while requests are being processed. The benefits of asynchronous applications include an improved user experience, the ability to handle multiple requests simultaneously, and more efficient resource utilisation.
Consider the scenario of uploading a video to YouTube. A synchronous application would lock the screen until the upload finishes, hindering user activity. An asynchronous application, on the other hand, allows users to continue using the application during the upload, providing a smoother experience.
While asynchronous applications are generally preferred for web development, synchronous applications may be necessary in specific cases, such as ensuring a request is completed before proceeding.

The JavaScript Event Loop:
The event loop is a fundamental part of JavaScript that facilitates the handling of asynchronous code. In a single-threaded language like JavaScript, where only one line of code can be executed at a time, the event loop is crucial for managing asynchronous tasks.
The event loop acts as a queue for asynchronous callbacks. When a callback is ready to be executed, it is added to the event loop queue, which then processes callbacks one by one. This single-threaded model, combined with asynchronous I/O, enables Node.js to handle multiple concurrent requests without blocking the main thread.
Understanding the event loop is essential for developers working with Node.js, as it enables the effective handling of asynchronous code and ensures optimal performance in handling multiple requests simultaneously. Careful usage of the event loop is necessary to avoid potential performance issues.

Conclusion:
In conclusion, Node.js stands out in the realm of server-side technologies due to its unique event-driven, non-blocking I/O model, which provides significant advantages in the development of scalable and efficient network applications. Because of its ability to use JavaScript on both the client and server sides, it is a popular choice for many modern web applications. While it excels at I/O-bound tasks and real-time applications, it is important to consider other technologies such as Python, Ruby, or PHP for CPU-intensive operations or when a different ecosystem might be more beneficial.
The vibrant and supportive Node.js community not only encourages continuous improvement and innovation but also provides a vast pool of resources and modules, empowering developers of all levels. Node.js remains a relevant and powerful tool in the ever-changing tech landscape thanks to regular updates and a focus on current web development trends.
As web technologies continue to evolve, Node.js will undoubtedly play an important role in shaping the future of server-side programming. Whether you are an experienced developer or just getting started, Node.js offers a dynamic and exciting journey into the possibilities of modern web development. Embrace the challenge and explore how Node.js can transform your next project.

My journey to becoming a developer

Ayomide Onibokun — Mon, 06 Apr 2020 13:04:48 +0000

First, let me introduce myself. My name is Ayomide Onibokun, and I’m a fullstack web developer, a software engineer with 5 years experience and a student of Oduduwa University Ipetumodu studying B.Eng Computer Engineering. In that time, I’ve worked as a trainer at xhub and also started a WordPress community in college and also a mentor at Repotecc.

I have always had this deep interest in tech from a young age, but faced the major limitation any individual hoping to set out in any career path faces, "Ideas and information on how to begin". I stumbled on a post from Fossbytes (Fossbytes is a tech blog), this post was an invitation to learning computer science online, one I had cravee for. I made use of the period before i gained admission into tertiary instituion to Learn this online course. This marked the beginning of my Journey as a developer.
Fueled by my Long desire to Journey into tech, I immediately made use of the links included in the post from fossybytes, which were links to site with contents to help meonmy new jorney as a developer. They included sites like Code.org (a site that teaches beginners programming in logic sequence, i was able to create a game), Khan academy (where I learnt about python), finally I then proceeded to YouTube in search about python and was captivated by a video "zero to hero with python". It spured my interest in python because it educated me about what python can do and current companies that uses it and that was my sight of motivation. Having gotten the required information, it was time to set goals. I decided to set a goal of learning how to build a website so I went on to search some YouTube video about html and css and one series I enjoyed was with a YouTuber named Bucky Robert. I was then admitted into college at Oduduwa University Ipetumodu having practiced enough.
My First real Challenge came when i was tasked with the responsibility of building a website For my Fellowship.This was when I was introduced to bootstrap ( Thanks to Ajayi Kayode who put me through), which is necessary due to its lightweight and easy customization. I also had to learn php for the back-end and wordpress theme development as it enables easy site management.
During my holiday, I advanced in my journey by Learning Java and andriod studio. I also lerned pygame with python and built some 2d games and then progressed to tkinter, pyqt, and kivy for building software i built a media player, browser and a texting app. Returning back to school we were taught Visual Basic 6.0, and It got much more interesting as I was now empowered to build desktop app easier and my first project was a hotel management system. I then proceeded to build software for a supermarket, pharmaceutical, a school receipt check clearance etc. lnspired by movies Like "Knight Rider, Iron man", I developed interest in Artificial Intelligence, and So I went in search of Knowledge. I thus learnt Machine learning With python which seams to be interesting.
I Have acquired skills in web and software development, machine learning, animation with after effects and started exploring and all were self taught and still wish to learn more but I what I want to advice the young generation is that you can be anything you want to be “If you can imagine it, you can achieve it. If you can dream it, you can become it.” By William Arthur Ward and always surround yourself with people having the same ambition with you, be resourcesful and determined. Attend seminars and try to utilize your social media as a source of learning new things and trends in tech by following people related to your ambition Thanks.