DEV Community: Adewumi Saheed Adewale

Tactical vs. Strategic Agentic AI Development — A Playbook for Developers

Adewumi Saheed Adewale — Fri, 26 Jun 2026 05:41:10 +0000

The Strategic Engineer: Why Writing Code Is No Longer Your Most Valuable Skill

Introduction: The Trap You Don't Know You're In

Picture this: your team just shipped a new payment feature. You used an AI agent to write the exception handler for failed transactions, the retry logic, and the edge-case validation for international currency codes. It took 40 minutes instead of a full afternoon. You feel productive.

Three sprints later, the product team asks you to extend payments to support subscriptions with variable billing cycles. You open the codebase and find a tangle of hardcoded edge cases, exception handlers that reference specific error codes from a now-deprecated API, and retry logic duplicated in four different files — all generated at 10× speed, with 10× the confidence of a developer who didn't think past Tuesday.

This is the Tactical AI Trap: using AI to solve the problem directly in front of you, without designing for the system around it.

Most developers are in this trap right now. Not because they're careless, but because the incentives of AI tooling push them there. Copilot auto-completes the exception. The agent patches the bug. The context window fills up with the current file, not the five files that will be affected next month. Speed masquerades as progress.

The shift that separates senior developers who scale with AI from those who drown in AI-generated debt is simple to state, hard to execute:

Stop using AI to write code. Start using AI to build systems.

This article is a playbook for that shift — from tactical to strategic agentic development.

Part 1: Tactical vs. Strategic Programming — What's Actually Different

Let's define terms precisely, because the distinction matters enormously in practice.

Tactical Programming means your unit of focus is the immediate task: this bug, this exception, this function. You treat the AI as a faster pair of hands. You say "fix the null pointer in getUserProfile()" and move on. The AI obliges.

Strategic Programming means your unit of focus is the system: the contracts between modules, the shape of data as it flows across services, the seams along which features will need to grow. You treat the AI as a junior engineer who needs architecture direction, not just a task description.

Here's a concrete comparison:

Tactical Prompt (What Most Developers Write)

Fix the bug where `order.total` is undefined when a coupon is applied 
at checkout.

The AI adds a null check. It works. The bug is gone. But the reason order.total can be undefined is that the pricing module and the coupon module don't share a single source of truth — they have divergent models of what an "order" looks like. That underlying problem just became slightly more hidden.

Strategic Prompt (What You Should Write)

We have a bug where `order.total` is undefined when a coupon is applied. 
Before fixing it, I want you to identify whether `PricingModule` and 
`CouponModule` share a consistent Order type, or whether each owns its 
own definition. If they diverge, propose a shared `OrderSummary` interface 
that both can depend on. Then fix the bug using that shared interface.

The second prompt takes 30 extra seconds to write. It produces a fix that makes the next five coupon-related features easier to build, not harder. That's leverage.

The practical rule: Before any AI prompt, ask yourself — am I solving this symptom, or am I improving the system that produced it?

Part 2: The Stateful Teacher — Why One-Off Prompts Are Killing Your Architecture

Here's a property of most AI interactions that most developers never think about: they are stateless by default.

Every time you open a new chat, the AI knows nothing about your codebase, your conventions, your architectural decisions, or the mistakes you made six weeks ago. You dump context, it solves a problem, you close the tab. The next session starts from zero.

This is fine for answering a quick question. It's catastrophic for building a long-lived codebase.

The reason is that architecture is cumulative. The decision you make about how to handle authentication today shapes how you'll build authorization next month. The schema design for User affects how you'll add multi-tenancy later. These decisions don't exist in isolation — they form a chain of reasoning that needs to be remembered across sessions.

The Teach Skill Philosophy

The open-source Teach skill addresses this directly. Instead of treating each AI session as a blank slate information dump, it establishes a stateful teacher-student relationship: the AI maintains a model of your project's mission, your learning goals, your past architectural decisions, and your current progress.

Think of the difference between:

Stateless AI: A brilliant stranger you meet at a conference who gives you great advice for 20 minutes, then disappears.
Stateful Teacher AI: A senior architect who has been embedded with your team for three months and knows exactly why you made every major decision.

In practice, the Teach skill works by persisting a structured context document — a living "codebase charter" — that gets loaded at the start of every session. Here's a simplified example of what that document might look like:

# Project: FinFlow — B2B Expense Management SaaS

## Core Architectural Decisions
- We use a shared `MoneyAmount` type (value + currency code) everywhere. 
  Never use raw `number` for money.
- All external API integrations live in `/adapters`. They implement 
  a shared interface; nothing in the core domain knows about Stripe or Plaid.
- The `User` entity does not hold company context. 
  CompanyMembership is a join model. This was a deliberate design for 
  future multi-org support.

## Mistakes We've Made (And Don't Repeat)
- We once let the `ReportModule` import directly from `BillingModule`. 
  This created a circular dependency. All cross-module data access 
  should go through events or shared DTOs.

## Current Sprint Goal
- Add recurring subscription support to the billing engine without 
  breaking the one-time payment flow.

When the AI loads this context, your prompts change in character. Instead of re-explaining your system every session, you're building on top of a shared understanding. The AI can flag when your new request violates a past decision. It can suggest the right seam for a new feature because it knows the existing seams.

The lesson: Your most valuable AI investment is not better prompts in the moment — it's building a persistent context that makes every future prompt smarter.

Part 3: Staying in Control — AFK Workflows and the Sand Castle Security Model

Once you've established strategic architecture and stateful context, a new possibility opens up: you don't need to babysit the AI.

Most developers watch their agent line by line, ready to hit stop the moment it does something unexpected. This caution is understandable — but it means you're bottlenecking on your own attention. You've traded one bottleneck (typing speed) for another (watching speed).

The strategic move is to design workflows where agents can run asynchronously — away from keyboard (AFK) — while you stay in control of what actually matters: the product vision and production systems.

The Sand Castle Model

The Sand Castle tool implements a clean security model for this: agents run inside secure, isolated sandboxes — the "sand castles." Inside a sand castle, an agent can read files, write code, run tests, and iterate. But it cannot touch production systems, commit to main, or make external API calls without an explicit checkpoint.

Here's what an AFK workflow looks like in practice:

Example: Triaging and fixing low-risk bugs overnight

At end of day, you create a task list of 12 low-risk bugs — null checks, off-by-one errors, missing input validation.
You feed the list to an agent running in a Sand Castle with read/write access to the dev branch, but no production credentials.
The agent works overnight: it reads each bug, writes a fix, runs the test suite, and generates a PR with a summary of its reasoning.
The next morning, you review 12 PRs in 45 minutes instead of spending 3 days writing the fixes yourself.

The key architectural decision here is the Human-in-the-Loop checkpoint: the agent cannot merge to main. It cannot deploy. Every change that touches production requires your explicit approval. You're not abdicating control — you're automating the work beneath the level of control that matters.

[Agent Loop - Sand Castle]
  ├── Read bug description
  ├── Locate relevant code
  ├── Write fix
  ├── Run tests
  ├── Generate PR + explanation
  └── STOP → await human review

[Human Checkpoint]
  ├── Review PR
  ├── Verify tests pass
  ├── Approve merge OR request changes
  └── Agent continues or terminates

The mental model shift: You're not a developer who watches AI. You're an architect who designs the boundaries within which AI operates, and a reviewer who approves what crosses those boundaries.

The AFK approach works precisely because you've done the strategic work upfront: the codebase is modular enough that the agent can change one thing without accidentally breaking three others. Tactical codebases can't be trusted to agents — too many hidden dependencies. Strategic codebases can be — because the dependencies are explicit.

Part 4: Procedures vs. Abilities — Keeping the Human in the Driver's Seat

As you work more with agentic systems, you'll notice they come with two fundamentally different kinds of skills:

Ability Skills are things the AI invokes on its own, autonomously, when it judges them relevant. You give it a goal; it decides what tools to call and when. High autonomy. Lower predictability.

Procedure Skills are things you invoke or sequence — step-by-step instructions that guide the agent through a workflow you've designed. Lower autonomy. Much higher predictability and control.

Most developer content celebrates Ability Skills. "Just tell the agent what you want and it figures it out!" This sounds great until you realize that an agent with high ability and a low-quality codebase is like a well-meaning intern with no documentation — it will confidently make things up.

Why Procedure Skills Win for Complex Systems

Consider the difference for a task like "add a new API endpoint."

Ability Skill approach (high autonomy):

Create a POST /api/invoices endpoint that creates an invoice for 
a given user and sends a confirmation email.

The agent will probably produce working code. But will it:

Follow your authentication middleware pattern?
Use your shared MoneyAmount type for amounts?
Register the route in the correct router file?
Add the right integration tests following your existing test patterns?
Emit the right domain event for the invoice-created lifecycle?

It might. It might not. You'll find out when you review 300 lines of plausible-looking code that doesn't quite fit the system.

Procedure Skill approach (guided sequence):

Follow our "Add API Endpoint" procedure:

Step 1: Create the request/response DTOs in /src/api/invoices/dto.ts 
        using our shared Money type for all monetary fields.
Step 2: Add the route handler in /src/api/invoices/invoices.controller.ts 
        using our AuthMiddleware decorator.
Step 3: Add the service method in /src/invoices/invoices.service.ts.
Step 4: Emit an InvoiceCreated domain event from the service method.
Step 5: Add integration tests in /test/api/invoices.test.ts following 
        the pattern in /test/api/payments.test.ts.
Step 6: Show me each file before moving to the next step.

This takes 90 seconds to write. But it produces code that fits your system, follows your patterns, and doesn't require you to mentally audit 300 lines of free-form generation. You stay in the driver's seat. The agent stays in its lane.

The rule: Use Ability Skills for well-scoped, low-risk, isolated tasks (generating a regex, writing a unit test for a pure function, drafting docs). Use Procedure Skills for anything that touches your system architecture, your data model, or your cross-module contracts.

Part 5: The Blank Slate Principle — Don't Bloat Your Context

Here's a temptation that hits every developer who gets serious about AI tooling: plugin accumulation.

You find a plugin that gives your agent access to your Jira board. Then your Slack channels. Then your GitHub PRs. Then your AWS console. Then your database schema. Then your analytics dashboard. Before long, you have 20 plugins loaded and you feel powerful.

What you've actually done is built a context window that looks like an overstuffed junk drawer. The agent now has access to everything and understanding of nothing. It hallucinates connections between systems because it's pattern-matching across too much noise. And when it fails, you have no idea which of the 20 inputs caused the bad output.

Start with a Blank Slate

The counter-intuitive approach: start with nothing. Strip back to baseline. Run the agent with just your codebase context and your core architectural document. Observe what it can and can't do well.

Then ask: what is the single biggest friction point in my workflow right now? Add exactly one integration or procedure to address that. Observe again. Repeat.

This is how you build an agentic workflow that actually fits your team, rather than a maximalist setup that sounds impressive in blog posts but fails in practice.

A Practical Layering Example

Here's how a team building a SaaS product might layer their agent setup over time:

Week 1 — Blank Slate
Context: codebase + architectural charter
Result: agent helps write modular code that fits the system; still needs handholding on cross-module tasks

Week 2 — Add One Procedure
Add: "Add Feature" procedure (5-step checklist for new features)
Result: new features now follow consistent patterns; agent stops inventing its own file structure

Week 3 — Add One Integration
Add: test suite runner with output piped into agent context
Result: agent can now run tests and self-correct before showing you the output; fewer back-and-forth cycles

Week 4 — Add One Ability
Add: ability to search internal docs for existing patterns
Result: agent stops reinventing solutions that already exist in your codebase; finds the right abstraction 80% of the time

Each layer is deliberate. Each one solves a specific, observed friction point. None of them were added because "more context = smarter AI." They were added because less friction = better outcomes.

Compare this to loading 20 plugins on day one. You'll spend more time debugging the agent's confused outputs than you'll save on development time.

The Blank Slate Principle: Treat every new capability you give an agent as a hypothesis. Define the expected improvement. Measure it. Keep it if it helps. Remove it if it doesn't.

Part 6: Putting It Together — A Strategic AI Development Workflow

Here's what the full strategic approach looks like in a real team's day-to-day:

Morning: Architecture Review (15 min)

Before touching code, review the architectural charter. Are there any new decisions from yesterday that need to be captured? Is the sprint goal still reflected accurately? Update the living document if needed. This is your investment in every future AI session being smarter.

Task Assignment: Triage by Risk Level

Before writing a prompt, categorize the task:

Risk Level	Examples	AI Approach
Low (Isolated)	Fix a typo, add a null check, write a pure function	Ability Skill, minimal context
Medium (Bounded)	Add a new API endpoint, write integration tests	Procedure Skill, architectural context
High (Cross-cutting)	Change data model, refactor a shared abstraction	Human-led, AI as assistant only
Critical (Production)	Deploy, database migration, access control change	Human only, AI excluded

During Development: Strategic Prompting

For every medium-risk task, open with architecture before code:

Before writing any code, tell me which existing modules this change 
will touch and whether there are any patterns in the codebase I should 
follow. Then follow our [relevant procedure name] procedure.

End of Day: AFK Handoff

Package low-risk tasks into a Sand Castle workflow for overnight processing. By morning, you have reviewed PRs, not a blank Jira board.

Weekly: Workflow Retrospective (30 min)

Ask: which agent outputs this week needed the most rework? Why? Was it a bad prompt, a missing procedure, or a gap in the architectural charter? Fix the root cause, not the symptom.

Conclusion: The Multiplier Effect

The developers who will define the next decade aren't the ones who use AI the most. They're the ones who architect for AI the best.

A tactical codebase — one full of hardcoded exceptions, duplicated logic, and ad-hoc integrations — gets worse with AI at the wheel. Every agent-generated patch makes it more brittle. Every one-off exception handler adds to the maze. Speed accelerates the accumulation of debt.

A strategic codebase — modular, well-scoped, with explicit contracts between components — becomes a force multiplier for AI. The agent can make changes confidently because the blast radius of each change is small and predictable. Procedures mean it follows your patterns instead of inventing new ones. The architectural charter means it builds on your decisions instead of overwriting them.

The senior developer's role hasn't been diminished by AI. It's been clarified. Your value was never in how fast you could type. It was always in how well you could think about systems — and that has never been more valuable than it is right now.

Your Challenge

Look at your last five AI prompts. Not the outputs — the prompts themselves.

Were they tactical patches? "Fix this bug. Handle this exception. Write this function."

Or were they strategic design instructions? "Before changing anything, map the contracts between these modules. Then propose the change that improves the system, not just the symptom."

If the answer is mostly tactical, you now know what to change. The AI isn't your bottleneck. Your prompts are.

Start with the charter. Write one procedure. Trust the sandbox. Stay strategic.

The tools mentioned in this article — the Teach skill, Sand Castle, and the Procedure Skill framework — represent an emerging philosophy of agentic development. The specific implementations matter less than the underlying principle: humans set the architecture, agents execute within it, and the system gets better with every sprint, not worse.

Benefits of Involvement in Tech Communities for Students and Beginners (Even Without a Tech Background!) - Part 2

Adewumi Saheed Adewale — Sun, 03 Mar 2024 18:01:47 +0000

Kindly Check the part 1 of the article part 1

Tech Trailblazers: Unleashing the Creativity Within (Even for Non-Tech Majors!)

As a beginner developer on campus with a non-tech major, have you ever felt the world of technology is buzzing with innovation, but you're not sure how to contribute? Well, guess what? You do have the potential to be an innovation catalyst in the tech ecosystem!

Here's how you, as a non-tech student, can ignite creative sparks and contribute to the ever-evolving world of technology:

1. Unleash Your Inner Problem Solver:

Identify needs and challenges: Look around your world, both online and offline. What problems do you or others face that could be addressed with technology?
Think outside the box: Don't be afraid to come up with unconventional solutions. Your unique perspective can lead to innovative approaches tech experts might not have considered.

2. Bridge the Gap Between Tech and Other Fields:

Combine your skills and passions: Do you love art and technology? Can you envision using code to create interactive art experiences? Maybe you're passionate about environmental issues and can brainstorm tech-driven solutions for sustainability.
Collaborate with tech enthusiasts: Connect with tech-savvy classmates or join clubs/events that bridge the gap between different disciplines. This can spark new ideas and help you translate your creative vision into technical realities.

3. Become a Tech-Savvy Storyteller:

Communicate complex ideas effectively: Whether through writing, graphic design, or even video editing, you can help explain complicated tech concepts to a wider audience in a clear and engaging way.
Promote innovation through storytelling: Use your storytelling skills to showcase the positive impact of technology on various aspects of life, inspiring others to see themselves as part of the innovation cycle.

4. Embrace Continuous Learning:

Explore tech resources: Online courses, tutorials, and even podcasts can introduce you to different aspects of technology, helping you understand its potential and limitations.
Stay curious and ask questions: Don't be afraid to ask questions, even if you feel like a beginner. Engaging in genuine curiosity can lead to insightful discoveries and open doors to new learning opportunities.

Tips, innovation thrives on diversity of thought. So, embrace your unique perspective, combine your skills with your passions, and don't be afraid to share your ideas. You might just become the next innovation catalyst in the tech ecosystem, even coming from a non-tech background!

Teamwork Makes the Tech Dream Work: Building a Support System for Problem-Solving

As a beginner developer on campus, you might encounter challenges and roadblocks during your learning journey. But don't worry, help is always closer than you think! Here's why building a support ecosystem is crucial for overcoming tech challenges:

1. The Power of Collective Wisdom:

Learn from others' experiences: Tap into the knowledge and expertise of your peers, professors, or online communities. They've likely faced similar challenges and can share valuable insights and solutions.
Gain different perspectives: Brainstorming with others can spark new approaches and help you avoid getting stuck in a single way of thinking. Sometimes, a fresh set of eyes can spot the solution you've been overlooking.

2. Collaborative Problem-Solving:

Break down complex problems: Working together allows you to divide and conquer, tackling individual components of a larger issue and then piecing them together for a comprehensive solution.
Share the workload and responsibility: Collaboration reduces the burden on any single individual and allows everyone to contribute their strengths, making the learning process more efficient and engaging.

3. Fostering a Growth Mindset:

Learn from mistakes: In a supportive environment, it's okay to make mistakes. Embrace them as learning opportunities for yourself and your team, fostering a growth mindset where everyone is encouraged to experiment and learn from their experiences.
Celebrate successes: Take time to acknowledge and celebrate both individual and collective achievements. This creates a positive and motivating atmosphere, encouraging everyone to keep learning and growing together.

Building Your Support System:

Connect with classmates: Form study groups, participate in coding clubs, or simply reach out to peers facing similar challenges.
Seek help from professors or mentors: Don't be afraid to ask questions in class, schedule office hours, or look for guidance from experienced individuals who can offer valuable mentorship.
Explore online communities: There are numerous online forums and communities where you can connect with tech enthusiasts, share your experiences, and learn from others facing similar challenges.

Benefits of Involvement in Tech Communities for Students and Beginners (Even Without a Tech Background!), Part 1

Adewumi Saheed Adewale — Thu, 29 Feb 2024 21:20:59 +0000

Joining tech communities has lots of perks for students and beginners. You can meet experienced professionals, learn about the latest tech trends, and make valuable connections. Being part of these groups lets you grow personally and professionally by getting mentorship, working on cool projects, and staying updated in the fast-changing tech world.

Networking on Campus: Making Friends in the Tech World (Even Without a Tech Background!)

Hey everyone! I'm a beginner developer here on campus, and maybe you're like me – interested in the tech world but not necessarily in a tech-related course. Don't worry, you can still build connections and explore opportunities in this exciting field! Here are some ways we, as non-tech students, can network on campus:

1. Find the Tech Hubs:

Clubs and Organizations: Look for clubs related to coding, entrepreneurship, innovation, or even specific technologies like robotics or game development. These clubs often welcome members from all majors and are a great way to meet like-minded people and participate in workshops or projects.
Career Centers and Events: Many career centers host events specifically focusing on tech careers. Attend these events to learn about different roles, companies, and potential pathways, even if you're not sure about a specific career yet.

2. Leverage Online Platforms:

Professional Networking Sites: Platforms like LinkedIn allow you to connect with professionals in the tech industry. Create a profile highlighting your skills and interests, even if they're not directly tech-related (communication, problem-solving, creativity are all valuable!).
Online Communities: Join online forums or groups relevant to tech topics you're interested in. Participate in discussions, ask questions, and connect with individuals within those communities (GDSC, Microsoft ).

3. Don't Be Afraid to Reach Out:

Professors and Advisors: Talk to your professors or advisors, even if they're not in the tech field. They may have connections in the industry or know about relevant opportunities on campus.
Upper classmen: Connect with upper classmen who are involved in tech activities or internships. They can offer valuable insights and advice based on their experiences.

Tips:

Be yourself: Don't feel pressured to portray yourself as a tech expert. Honesty and genuine interest go a long way in building connections.
Focus on common ground: Highlight your transferable skills and passions. Show your enthusiasm for learning and collaborating, even if you're coming from a different background.
Start small and build gradually: Networking is a marathon, not a sprint. Start by attending events or joining online groups, then gradually build relationships with individuals you connect with.

By taking these steps, you can start building your network in the tech sphere, even as a beginner and non-tech student. Remember, networking is about making connections, learning from others, and exploring the possibilities in the tech world, all while building valuable skills along the way!

Never-ending Knowledge Hunt: Staying Sharp in the Tech World (Even As a Non-Tech Major!)

Hey fellow explorers! As a beginner developer on campus with a non-tech major, I know the tech world can feel vast and ever-changing. But guess what? Continuous learning is the key to staying sharp and thriving in this exciting field, even if your academic path isn't directly tech-related. Here are some ways we can embrace knowledge exchange within the tech circles:

1. Seek Out Learning Resources:

Online Courses and Tutorials: Platforms like Coursera, edX, and Udemy offer a vast library of free and paid courses on diverse tech topics – from coding basics to data analysis. Take advantage of these resources to explore new areas and expand your knowledge base.
Tech Blogs and Podcasts: Subscribe to blogs and podcasts written and hosted by developers, industry experts, or tech enthusiasts. They offer valuable insights, practical tutorials, and discussions on current trends, keeping you up-to-date.
Books and Articles: Dive into books and articles written by renowned tech leaders or on specific technologies you find fascinating. Reading different perspectives can broaden your understanding and spark new ideas.

2. Participate in Knowledge Sharing:

Coding Bootcamps and Workshops: Attend coding bootcamps or workshops offered on campus or online. These intensive programs can introduce you to new programming languages, frameworks, and coding methodologies in a short time.
Hackathons and Coding Challenges: Participate in hackathons and coding challenges, either individually or as part of a team. These events provide a fun and collaborative environment to work on real-world projects, learn from others, and test your skills.
Meetup Groups and Online Forums: Join meetup groups or online forums related to your interests within the tech world. These platforms facilitate discussions, knowledge sharing, and collaboration among diverse individuals, fostering continuous learning and growth.

3. Embrace the Power of Collaboration:

Find a Mentor: Connect with a mentor, whether an upper classman with tech experience, a professor specializing in a tech-related field, or even a professional willing to share their knowledge. They can guide you through your learning journey, answer your questions, and provide valuable feedback.
Work on Open-Source Projects: Contribute to open-source projects. This allows you to learn from working code, collaborate with developers globally, and gain practical experience while contributing to the tech community.
Form Study Groups: Find other students on campus who share your interest in learning different aspects of tech. Form study groups, discuss concepts, work on projects together, and support each other on your learning journeys.

Tips, continuous learning is a lifelong journey. Embrace the vast resources available, actively participate in knowledge exchange, and collaborate with others. By staying curious and constantly seeking new ways to learn, you'll be well on your way to becoming a tech-savvy individual, irrespective of your academic background!

How Setup Gemini AI for REST API using NodeJs

Adewumi Saheed Adewale — Tue, 27 Feb 2024 10:30:37 +0000

Project Prerequisites:

Node.js v18+
npm

Setting up Gemini AI for a REST API using Node.js involves a few steps. Gemini AI is a machine learning platform that offers various features for building and deploying machine learning models. Here's a basic guide on how to set up Gemini AI with Node.js for a REST API:

Sign up for Gemini AI: If you haven't already, sign up for an account on the Gemini AI website (https://deepmind.google/technologies/gemini/#introduction) and Build with Gemini (https://ai.google.dev/).

Create your API Key: Train or upload a machine learning model using the Gemini AI platform. Follow the instructions provided by Gemini AI to create and train your model based on your specific requirements.

For Documentation:
(https://ai.google.dev/tutorials/node_quickstart)

Create your project & Install Dependencies: In your Node.js project directory, initialize a new project if you haven't already, and install necessary dependencies:

mkdir gemini_nodes_api
npm init -y
npm install express axios body-parser

Set Up Your Node.js Server: Create a new file, index.js and .env, and set up a basic Express server:

const express = require('express');
const bodyParser = require('body-parser');

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

console.log(genAI);

const app = express();
const port = process.env.PORT || 3001;

// Middleware to parse JSON bodies
app.use(bodyParser.json());

// Route to handle form submissions
app.post('/submit-form', (req, res) => {
    const formData = req.body;

    res.json(formData);
});

app.post('/text', async (req, res) => {
  const prompt = req.body.prompt;

  try {
    const model = genAI.getGenerativeModel({ model: "gemini-pro"});
    const result = await model.generateContent(prompt);
    const response = await result.response;
    const text = response.text();

    res.json({ text });
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Failed to generate text' });
  }
});


// Start the server
app.listen(port, () => {
    console.log(`Server is running on port ${port}`);
});

Replace 'API_KEY' with the actual URL provided by Gemini AI for making predictions.

Test Your API: Start your Node.js server by running node server.js in your terminal. You can then send POST requests to http://localhost:3000/text with the input data you want to make predictions on.

 node index.js

Remember to handle authentication, error handling, and any other necessary features according to your project requirements and Gemini AI's API documentation.

Enjoy your reading

Ƙunshi zuwa CLI da Cloud CLI Kayan Aikin

Adewumi Saheed Adewale — Wed, 07 Feb 2024 17:41:56 +0000

Here's the translation of the provided text into Hausa:

Kuna san lokacin da kake fama da shi ko Terminal interface?

Me yake CLI?
CLI wanda ke nufin "Command-Line Interface," shine wani yanayin amfani da mai rubutu da aka yi na fayyace tare da tsarin ɗan lokaci ko konsoli da yaɓaka rubutu don shiga cikin tashar komai da kayayyakin. CLI shine wani yanayi wanda ke da shan hankali da kuma mahimmanci don ganin kwarewar hanyar da za'a yi, dan kuma samun amfani game da irin shirya da za'a iya yi, sabis game da mana yankin komai da kayayyakin.

Sauƙi na CLI

Kayan shafukan Rana na Kayan

Nakasa Mai Nasara na Windows: Wannan shine yanayi mai sauki na kayan Rubutu don Microsoft Windows. Ma'aikata za su iya samun shi ta hanyar running cmd ko cmd.exe.
PowerShell na Windows: PowerShell shine wani aiki na CLI don Windows da kayan aikin mai girma.
Kayan Shafu na Linux: A bisa masu amfani da kayan aikin Linux, masu amfani za su iya amfani da kayan kamar GNOME Terminal, Konsole, ko kayan shafu na asali na kayayyakin desktop.
Terminal na macOS: macOS ya bayyana ɗan tsarin bayanin gaban kayan shafin.

Kayan shafukan Fasali:
Wasu wasu na fasali na fasali da aka bayyana suna bayyana na fasali na fasali wanda ke aiki ne ya ba masu amfani damar shiga tashar, fushin, ko kuma kayayyakin game da ake samun na fasali ta fasali. Misali suna hada da AWS CloudShell, Google Cloud Shell, da Azure Cloud Shell.
Kayan shafukan SSH:

Shafin Taimako (SSH) shine wani tsari da ya bada taimako don ganewa na gaban kayan shafu da kuma kayan shafu. Masu amfani za su iya ganewa da gaban kayan shafu ta fasali tare da amfani da aikace-aikace na SSH da su kayan shafu na fasali.

Kayan shafukan Amfani (IDE):

An samu wasu shafu na tallacewa da tallacewa da aka haɗa da su cikin rubutun tallaɗa da tallaɗa, kamar Visual Studio Code (VS Code). Wadannan kayan shafu na fasali suka fara amfani da manyan masu aikata na tallace-tallace da rikicin a lokacin da suke tallaɗa.

Kayan shafuka ta Fasalin:

Kayan shafuka ta fasali an samu su don ganin da aka sanya shi ga shi ne. Wasu fasalai da kayayyakin da ake samun ya zo suna da fasali na fasali suka ga kayan shafu ko shafu.

Wannan na doguwar da aka fayyace da kayan shafu, wanda a matsayin wani mahaifi ne don abu mai sauki, mai da shan hankali, da kuma da shan tsarin rubutu, wanda ya sa shi shi ne na mahaifi don sauyi sababbin alamomi na fasaha, rubutun aikin aiki, da sauransu.

Me yake Cloud CLI?
Cloud CLI (Command-Line Interface) ya zama hukunci da wata hanyar kayan rubutu ko tashe masu amfani don ganin ɗan'adamai cikin kwarewar tashar komai da kayayyakin. Ya kara amfani da masu amfani don saƙar shawarwari, zama, da bugawa masu amfani da kayan tashe masu amfani don shigar da amfani game da saiti na fasali na fasali da kuma rubutun.

Karancin Ayyukan Na Amfani na Fasali

Alamomi da Kayan Rubutu na Rubutu: Kayan Cloud CLI suna amfani game da kayan rubutu masu rubutu don a yi amfani da samfuran aikin tashe masu amfani a cikin fasalin ko shafin shafin shafin. Wadannan rubutun suna tallafawa ta hanyar mara waɗannan cikakken rubutu game da matukar rubutu da suka kara rubutu.

Saƙar Shawarwari: Kayan Cloud CLI suna amfani da saƙar shawarwari, da kuma karin saƙar shawarwari don farko, masu saurare da masu ba da mace masu saurare masu saurare su za su iya shigar da rubutu na fasali a kan tashar, sauraren aikin shigarwa. Wannan za a iya saukar da alamu, bude, hallara, da kuma wasu.

Mana Ƙwararri: Da Kayan Cloud CLI, masu amfani za su iya yi mukami, sauraron, kaddamar da madaukakin kayayyaki, da kuma kaddamar da masu amfani ta Cloud kamar virtual machines, databases, kayan aji, containers, da sauransu.

Ƙunshi zuwa CLI da Cloud CLI Kayan Aikin

Adewumi Saheed Adewale — Wed, 07 Feb 2024 17:41:56 +0000

Here's the translation of the provided text into Hausa:

Kuna san lokacin da kake fama da shi ko Terminal interface?

Sauƙi na CLI

Kayan shafukan Rana na Kayan

Nakasa Mai Nasara na Windows: Wannan shine yanayi mai sauki na kayan Rubutu don Microsoft Windows. Ma'aikata za su iya samun shi ta hanyar running cmd ko cmd.exe.
PowerShell na Windows: PowerShell shine wani aiki na CLI don Windows da kayan aikin mai girma.
Kayan Shafu na Linux: A bisa masu amfani da kayan aikin Linux, masu amfani za su iya amfani da kayan kamar GNOME Terminal, Konsole, ko kayan shafu na asali na kayayyakin desktop.
Terminal na macOS: macOS ya bayyana ɗan tsarin bayanin gaban kayan shafin.

Kayan shafukan Fasali:
Wasu wasu na fasali na fasali da aka bayyana suna bayyana na fasali na fasali wanda ke aiki ne ya ba masu amfani damar shiga tashar, fushin, ko kuma kayayyakin game da ake samun na fasali ta fasali. Misali suna hada da AWS CloudShell, Google Cloud Shell, da Azure Cloud Shell.
Kayan shafukan SSH:

Kayan shafukan Amfani (IDE):

Kayan shafuka ta Fasalin:

Kayan shafuka ta fasali an samu su don ganin da aka sanya shi ga shi ne. Wasu fasalai da kayayyakin da ake samun ya zo suna da fasali na fasali suka ga kayan shafu ko shafu.

Karancin Ayyukan Na Amfani na Fasali

Tips to get your Google Cloud certification for beginner

Adewumi Saheed Adewale — Fri, 13 Oct 2023 20:02:14 +0000

Article outline
If you’re into software engineer or as developer then you have probably heard of Cloud or Google Cloud. To help you get started with Google Cloud check out to learn more

Why get Google Cloud certified

87% of Google Cloud certified users feel more confident in cloud skills.
More than 1 in 4 of Google Cloud certified individuals took on more responsibility or leadership roles at work.

Planning to taking Google cloud certification for your career

Select the Certification Paths: Google Cloud offers various certifications, such as Associate, Professional, and Specialization certifications. Choose the one that aligns with your career goals and current skill level. Some popular options include the Google Cloud Associate Cloud Engineer, Professional Cloud Architect, and Professional Data Engineer certifications.

Review Exam Guides: Google provides detailed exam guides for each certification, which outline the topics and skills that will be tested. Review these guides to understand what you need to study.

Training and Learning: Google Cloud provides various resources, including documentation, online courses, and hands-on labs. You can use platforms like Coursera, Udemy, and Pluralsight for structured courses. Additionally, Google's Cloud offers hands-on labs for practical experience.

Hands-on Practice: Practical experience is key. Create a Google Cloud account (you may be eligible for free credits) and practice setting up different services, deploying applications, and managing resources. This hands-on experience is invaluable.

Use Practice Exams: There are many practice exams available online that mimic the real certification exam. These can help you get a feel for the types of questions and the time pressure.

Community or Webinars session: Join online study groups or forums where you can discuss topics with others who are also preparing for the same certification. Sharing knowledge and experiences can be very helpful.

Others tips

Don't overwhelm yourself with resources
Focus on basic concept of cloud
Have Good plan about your Examination (online or Onsite) {I prefer the onsite Examination}
Don't jumpstart the certification process within short time plan

How to Create compute instance in Oracle Cloud Infrastructure

Adewumi Saheed Adewale — Wed, 04 Oct 2023 06:42:04 +0000

To get started on Oracle Cloud Infrastructure

Step 1

Sign In to Oracle Cloud: Go to the Oracle Cloud website https://cloud.oracle.com/ and sign in to your Oracle Cloud account.

Note if you do not have Oracle account you are expected to create Oracle cloud Infrastructure Account. Verify your email address add your credit card and start using the infrastructure services

Step 2
Navigate to the Compute Services

Click on create compute

In this article I called my instance rider_pack

In creating instance Oracle features gives you chance to update your configuration like

Image and shape
Choose Oracle Linux OS for instance

Note the higher the specification the higher the cost of the infrastructure advisable you choose minimal specifications, and you can scale up later.

From the above image, the excepted cost at end of the month is 1.85 Euro

Click create button to create your instance

Make sure you download private key to access your instance using SSH connection

You can now access the instance after creating the Cloud Infrastructure

In my next article on oracle. I will share you how to set up and deploy your project on oracle platform.

Cloud Management Console vs Cloud Management CLI Platform

Adewumi Saheed Adewale — Mon, 02 Oct 2023 05:44:37 +0000

A Cloud Management Console is a web-based interface provided by cloud service providers (e.g., Amazon Web Services, Google Cloud Platform, Microsoft Azure) to allow users and organizations to manage and administer their cloud resources and services. This console is a central hub for configuring, monitoring, and optimizing cloud-based infrastructure and applications. Here are some common features and functionalities you can typically find in a Cloud Management Console:

Using a Cloud Management Console offers several advantages for individuals and organizations that leverage cloud computing services. These advantages can help streamline operations, improve efficiency, enhance security, and optimize costs. Here are some of the key advantages:

Centralized Control: Cloud Management Consoles provide a single, centralized interface to manage all cloud resources and services. This simplifies administration by eliminating the need to navigate multiple tools or interfaces.
Ease of Use: Most Cloud Management Consoles are designed to be user-friendly, making it easier for both technical and non-technical users to manage cloud resources without requiring in-depth technical expertise.
Resource Scalability: Users can easily provision and scale cloud resources up or down as needed to accommodate changing workloads, ensuring optimal resource utilization and cost efficiency.
Security Management: Cloud Management Consoles often include robust identity and access management (IAM) features, allowing organizations to control who can access and modify cloud resources, enhancing security.
Cost Control: Cloud Management Consoles offer tools for monitoring resource usage and costs. Users can set budgets, receive cost alerts, and optimize resource allocation to control cloud spending effectively.
Automation: Many consoles support automation through scripts or templates, enabling the automatic provisioning and configuration of resources, reducing manual intervention and potential errors.
Monitoring and Alerts: Users can monitor the health and performance of their cloud resources in real-time. Alerts and notifications can be set up to detect and respond to issues promptly.
Resource Optimization: Cloud Management Consoles often include recommendations and insights on optimizing resource usage, improving cost-efficiency, and enhancing application performance.
Marketplace Access: Cloud marketplaces within the consoles offer a wide range of third-party applications and services that can be easily integrated into existing cloud environments.

Cloud Management CLI

A Cloud Management CLI (Command-Line Interface) is a text-based interface provided by cloud service providers that allows users to interact with and manage their cloud resources and services using text commands. It is an alternative to graphical user interfaces (GUIs) and is especially popular among developers, system administrators, and DevOps professionals who prefer command-line tools for scripting, automation, and more advanced configurations.

How to get started Cloud Management Console (GCP USE-CASE) vs Cloud Management CLI Platform (Google Cloud Platform)

If you don't already have a GCP account, visit the Google Cloud Platform website (https://cloud.google.com or https://cloud.google.com/gcp/) and sign up for a GCP account.

You'll need to provide billing information, but Google often offers a free trial with a $300 credit to get you started.
Create a GCP Project:

Click on the project dropdown menu (located near the top of the page) and select "New Project."
Follow the prompts to create a new GCP project. Projects help
organize and manage resources.
Enable Billing:

Before you can use GCP resources, make sure billing is enabled for your project. You may need to set up a billing account or link an existing one.
Navigate to the Cloud Console:

Once your project is created and billing is set up, you can access the Cloud Management Console.
From the GCP Console homepage, click on the "Navigation Menu" (☰) in the top left corner, and under the "Management Tools" section, select "Cloud Console."

Explore the Cloud Console:

Once you're in the Cloud Console, you can explore its features and resources.
You'll see a dashboard that provides an overview of your project's resources and activity.
Create and Manage Resources:

Use the Cloud Console to create and manage cloud resources such as virtual machines, databases, storage buckets, and more.
You can use the navigation menu on the left to access various GCP services & access CLI in GCP Console

How to Get started with GCP CLI

Install the Google Cloud SDK:

Go to the Google Cloud SDK download page and download the appropriate installer for your operating system (Windows, macOS, or Linux).

Follow the installation instructions provided for your specific operating system to install the Google Cloud SDK.

Initialize the SDK:

After installation, open a terminal or command prompt on your computer.
Run the following command to initialize the Google Cloud SDK and authenticate with your GCP account:

gcloud init

Others helpful command

You can access the official Google Cloud CLI documentation

gcloud help

*Set Default Region and Zone *
gcloud config set compute/region [REGION] gcloud config set compute/zone [ZONE]

You can also check official documentation Google Cloud CLI documentation

_In my next blog we are discussing setup CLI and create project and manage your resources _

Introduction to CLI & Cloud CLI Tools

Adewumi Saheed Adewale — Sun, 01 Oct 2023 09:18:01 +0000

Are you familiar with the CMD or Terminal interface

What is CLI?
CLI which stands for "Command-Line Interface," is a text-based user interface used to interact with computer systems and software by entering text commands into a terminal or console. A CLI is a versatile and efficient way to perform various tasks, automate processes, and manage computer systems.

Type of CLI

Operating System Terminals:

Windows Command Prompt: This is the default command-line interface for Microsoft Windows. Users can access it by running cmd or cmd.exe.
Windows PowerShell: PowerShell is an advanced CLI for Windows with powerful scripting capabilities.
Linux Terminal: On Linux-based operating systems, users can use terminals like GNOME Terminal, Konsole, or the default terminal emulator of the respective desktop environment.
macOS Terminal: macOS provides a terminal application for accessing the command-line interface.

Web-Based Terminals:
Some cloud providers and web services offer web-based terminals that allow users to interact with virtual machines, containers, or cloud resources through a browser. Examples include AWS CloudShell, Google Cloud Shell, and Azure Cloud Shell.
SSH Terminals:

Secure Shell (SSH) is a protocol that allows secure remote access to servers and systems. Users can connect to remote servers using SSH clients and interact with CLIs on the remote machines.

Integrated Development Environment (IDE) Terminals:

Many code editors and integrated development environments, such as Visual Studio Code (VS Code), offer integrated terminals. These terminals are often used by developers for running commands and scripts while coding.
Serial Terminals:

Serial terminals are used for communicating with embedded systems and devices that use serial communication. Terminal programs like PuTTY and Tera Term are commonly used for this purpose.

Database Terminals:

Database management systems (DBMS) often provide command-line interfaces for querying and managing databases. For example, MySQL and PostgreSQL have their own CLIs for database administration.

In an advance way

Specialized Terminals:
Some specialized applications and tools may include their own custom CLIs, accessible through dedicated terminals or consoles.

In a CLI environment, users typically enter commands, arguments, and options to interact with software, perform system tasks, run scripts, and manage files and directories. The output of these commands is displayed in the same terminal, making it a powerful tool for system administration, software development, and automation.

CLIs are known for their efficiency, flexibility, and scriptability, which make them valuable for a wide range of tasks, including server administration, software deployment, data manipulation, and more.

What is Cloud CLI?
Cloud CLI (Command-Line Interface) refers to a command-line tool or interface provided by cloud service providers to interact with their cloud platforms and services. It allows users to manage, configure, and monitor cloud resources and services using text-based commands and scripts.

Advantage of Using Cloud CLI Platform

Text-Based Commands: A Cloud CLI allows users to perform various operations on cloud resources by entering text-based commands in a terminal or command prompt. These commands are typically designed to be human-readable and follow a specific syntax.

Automation: Cloud CLIs are essential for automation, enabling developers and administrators to script and automate repetitive tasks and workflows. This can include provisioning virtual machines, deploying applications, configuring networking, and more.

Resource Management: With a Cloud CLI, users can create, update, delete, and manage cloud resources such as virtual machines, databases, storage, containers, and more. It provides granular control over cloud infrastructure.

Access Control: Cloud CLIs often provide tools for managing access control and security settings. This includes user and group management, authentication, authorization, and setting permissions on resources.

Scripting: Cloud CLIs can be used in scripts and automation workflows to orchestrate complex cloud operations. This scripting capability is valuable for DevOps practices and infrastructure as code (IaC) approaches.

Cross-Platform: Most Cloud CLIs are designed to work on multiple operating systems, including Windows, macOS, and various Linux distributions. This ensures that users can interact with cloud services regardless of their choice of development environment.

Integration: Cloud CLIs are often used in conjunction with other tools and platforms. They can be integrated into continuous integration and continuous deployment (CI/CD) pipelines, configuration management systems, and monitoring solutions.

Next post: Console vs CLI Platform