Forem: AbdlrahmanSaber

Stop Starting From Scratch: How Claude Projects Will Change the Way You Work

AbdlrahmanSaber — Sun, 03 May 2026 08:03:33 +0000

What Is a Claude Project?

A Project is a persistent workspace inside Claude. Think of it as a dedicated room where you and Claude work together on a specific area of your life or work — and unlike a regular chat, it doesn't forget anything between sessions.

Each Project has three key parts:

Custom Instructions — a set of guidelines that shape how Claude behaves inside that project. Always. Every conversation.

Knowledge Files — documents, notes, and files you upload that Claude can reference in every conversation within the project.

Conversation History — all your past chats inside that project are preserved and accessible.

The context window for a Project is 200,000 tokens — roughly equivalent to a 500-page book. That's a lot of room to work with.

The mental model is simple: if a regular Claude chat is a sticky note, a Project is a notebook. One is for quick thoughts; the other is where real work happens.

Custom Instructions: The Feature Most People Skip

When you create a Project, you get a field called "Custom Instructions." Most people leave it blank or type something vague like "be helpful and professional." That's a waste.

Custom Instructions are how you give Claude a standing brief — the kind of context you'd give a new colleague on their first day. Except you only have to write it once.

What to include in strong custom instructions:

Your role and context. Tell Claude who you are. "I'm a freelance UX writer working with B2B SaaS clients" is more useful than nothing. Claude will calibrate its vocabulary, assumptions, and suggestions accordingly.

Tone and style preferences. Do you want formal or conversational? Bullet points or prose? Short and direct, or thorough? Spell it out. Claude will default to something reasonable, but "something reasonable" isn't the same as your preference.

What to always do. If you always want sources cited, say so. If you always want a summary at the top of long answers, say so. If you want Claude to push back when your ideas have holes, say so.

What to never do. "Don't use bullet points unless I ask" or "never suggest I use a different tool" — these kinds of guardrails save a lot of back-and-forth over time.

An example of weak vs. strong custom instructions:

Weak:

"You are a helpful assistant. Be professional and concise."

Strong:

"I'm a product manager at a fintech startup. I'm working on reducing user churn. I prefer direct answers — lead with the conclusion, then explain. When reviewing my writing, give honest feedback and don't soften criticism. Never use corporate buzzwords. If I ask for a framework or process, give me one I can actually use in a meeting, not a textbook definition."

The second version saves you from re-explaining yourself in every single conversation. Over weeks of use, that compounds into a noticeably smarter working relationship.

Knowledge Files: Give Claude Something to Work With

The second pillar of Projects is Knowledge Files — the documents and materials you upload to a Project for Claude to draw from.

This is what turns Claude from a general assistant into something that actually understands your work.

Here's the idea: any document you find yourself referencing repeatedly in conversations — a style guide, a brief, a set of notes, a template — should live in your Project's knowledge base instead of being re-pasted into every chat.

What to upload:

Style guides or voice docs — if you're using Claude for writing, upload the brand voice guidelines or your personal writing principles. Claude will match the tone without you having to describe it from scratch.
SOPs or process docs — upload your team's workflows or your own operating procedures. Ask Claude how to handle a situation and it'll answer based on how you actually work, not a generic answer.
Research or reference material — working on a long-form project? Upload your notes, interview transcripts, or source documents. Claude can summarize, cross-reference, and synthesize across all of it.
Past work samples — give Claude examples of writing, analyses, or outputs you're proud of. It gives Claude a calibration point for the quality and style you're aiming for.

One important tip: be selective. It's tempting to dump everything into a Project and let Claude sort it out. Don't. Focused, high-quality context produces better results than a pile of loosely related documents. If you're not sure a file belongs, it probably doesn't — yet.

Five Projects Worth Creating Today

If you're not sure where to start, here are five concrete Project setups that work well for most people.

Job Search Project
Upload your current CV, a list of target roles, any cover letter templates you've used, and notes on companies you're watching. Custom instruction: "I'm actively job hunting. Help me tailor applications, prep for interviews, and research companies. Be direct about what's weak in my materials."

Writing / Content Project
Upload your style guide, a few past pieces you're proud of, and any editorial brief you're working from. Custom instruction: "Match my voice. Don't clean up my sentence fragments unless they're unclear. Push back if a headline is weak."

Work Project
Upload your team's internal docs, a glossary of terms, your org chart if relevant, and any recurring templates. Custom instruction: "I work in [role] at [company type]. Use our internal terminology. When I ask for an email or document, match our internal style."

Learning Project
Upload lecture notes, reading summaries, or course materials. Custom instruction: "I'm trying to understand [topic] deeply. Use the Socratic method when I get things wrong. Give me examples from [domain I already know]."

Side Project / Startup
Upload your product spec, user research notes, competitor notes, and any pitch material. Custom instruction: "We're building [brief description]. I'm the [role]. Prioritize speed and practical thinking over polish."

Tips for Getting the Most Out of Projects

Write your custom instructions like you're onboarding someone. Not vague adjectives ("be concise") but actual behavioral guidance ("when I ask for a plan, give me numbered steps with time estimates").

One Project per context, not per task. Don't create a new Project every time you start a new piece of work. A "Writing" Project covers all your writing work. A "Job Search" Project covers the whole job hunt. Projects are contexts, not folders.

Update your instructions when something annoys you. If Claude keeps doing something you don't want, that's a signal — add a line to your custom instructions. The relationship improves as you refine it.

Keep knowledge files current. If you update a style guide or process doc, re-upload it. Stale context produces stale answers.

Use conversation history deliberately. Because your history is preserved, you can ask Claude to refer back to decisions made in earlier sessions. "Based on the brief we discussed last week, draft the intro" is a perfectly valid prompt.

The Bigger Shift

The underlying idea here is simple but easy to miss: Claude is only as useful as the context you give it.

A regular chat gives Claude nothing but your most recent message. Projects give Claude your role, your preferences, your documents, and your history — all at once, every time. That's not a small upgrade. It fundamentally changes what the tool can do for you.

The people getting the most out of Claude aren't necessarily using better prompts. They're working inside Projects, with well-written instructions and a curated knowledge base. They're treating the relationship like a collaboration, not a search engine.

So: what would your first Project be?

If you already have one set up, drop your custom instructions in the comments — I'd genuinely love to see what's working for other people.

If you found this useful, follow me here for more practical pieces on working with AI tools. I write for practitioners, not hype.

Debug MCP Like Network Tab: Seeing Every Tool Call in Real Time

AbdlrahmanSaber — Fri, 01 May 2026 16:58:46 +0000

You triggered a tool call from Cursor, something went wrong, and the only feedback was silence—or a vague error. The server is running, the tool is registered, but you have no idea what actually crossed the wire. This article walks through getting a browser-based trace of every JSON-RPC message without touching your server code.

Disclosure

I maintain mcpkit. This article explains how I use it to inspect Model Context Protocol traffic—I am biased, but the problem is real whether you use this tool or another.

What is MCP?

Model Context Protocol (MCP) is an open protocol—introduced by Anthropic—that standardises how AI models connect to external tools and data. Think of it as a USB standard for AI capabilities: instead of every model and every tool inventing their own integration, they speak a shared language.

The two main actors:

MCP client — the AI host: Cursor, Claude Desktop, VS Code with Copilot, or any app that wants to call tools on behalf of an LLM.
MCP server — a small process (yours, or a third party's) that exposes tools, resources, and prompts over the protocol.

When an AI decides it needs to query a database or fetch documentation, it sends a tools/call request to the relevant MCP server. The server runs the function and returns a result. All of this is JSON-RPC—typically over stdio pipes (stdin/stdout), though HTTP+SSE transports exist too.

That's the handshake. The rest of this article is about what happens when that handshake goes wrong.

The black box

MCP connects AI clients to tools: databases, APIs, filesystems. Under the hood the client and server exchange JSON-RPC messages—often over stdio (stdin/stdout pipes). Everything works until it doesn't: slow calls, wrong arguments, silent failures.

Terminal logs help, but they rarely show:

Which JSON-RPC method ran (tools/call, resources/list, …).
Latency end-to-end.
Full request and response payloads side by side.
Whether the failure was protocol-level or inside the tool result.

You need something closer to a network tab: a live list of interactions with drill-down—not a grep war.

Transparent proxy: no server surgery

mcpkit sits between the MCP client and your server process. You don't patch your MCP server code. You wrap the spawn command:

npx @abdlrahmansaber/mcpkit inspect -- node ./dist/server.js

(or mcpkit if installed globally.)

The inspector:

Starts your server as a child process.
Copies traffic on stdin/stdout through a transparent proxy.
Opens a browser dashboard with a trace table.

What you see on the dashboard

Typical workflow:

npm install -g @abdlrahmansaber/mcpkit
mcpkit inspect -- node path/to/your-mcp-server.js

Stderr prints a line like:

[mcpkit] inspector dashboard: http://localhost:3200

Open that URL. For each message you'll see:

Signal	Why it matters
Direction	Client → server vs server → client
Method	e.g. `tools/call`, `tools/list`
Tool	Which tool name (for `tools/call`)
Latency	Time for paired request/response
Status	OK, error, timeout, pending

Click a row to open request and response JSON. That's how I confirmed Flux queries, API keys in params (then moved them to env), and slow buckets.

Trace table — several rows (mix success / error). Alt text example: "mcpkit inspector dashboard showing method, tool name, latency, and status columns."
Detail panel — expanded row with Request / Response JSON for a tools/call. Alt text example: "Expanded MCP trace showing JSON request and response for a tools/call."

CLI options worth knowing

--port 3201 — if 3200 is busy.
--log-only — stderr logging only, no browser (CI or SSH).
--export traces.json — dump collected traces on exit.
--server-name my-influx — label traces when you run multiple proxies later.

What's next

Inspecting one server covers a lot of debugging. When you run several MCP servers at once—Influx, Postgres, docs fetchers, whatever—you usually configure each spawn command in whatever MCP host you use: Cursor (.cursor/mcp.json or project MCP config), Claude Desktop (claude_desktop_config.json), VS Code and other editors with MCP support, or any launcher that starts servers over stdio. Same idea everywhere: wrap the command so traffic can be traced.

For multi-server setups you want one shared dashboard and a Server column — that’ll be in the next article. `mcpkit serve` plus `mckit proxy` with `--inspector` in each configured command (adapt the snippet to your tool’s JSON shape).

Feel free to connect 🌹me on:

Convert enum to string literal union type in TS

AbdlrahmanSaber — Sat, 29 Oct 2022 14:40:44 +0000

Hello everyone, this is a quick tutorial, In my work, I wanted to avoid duplicating code as I can and abstract things for example if I use an enum named Weekdays and it contains the following data:

enum Weekdays = {
    MONDAY = 'mon',
    TUESDAY = 'tue',
    WEDNESDAY = 'wed'
}

Let's say you want to create a type called WeekdayType which should contain 'mon' | 'Tue' | 'Wed', how we can do this? Starting from version 4.1 you can do a tricky thing to do it in a single line of code, let's see it.

type WeekdayType = `${Weekdays}`;
// WeekdayType = 'mon' | 'Tue' | 'Wed'|

Congratulations, you did it! Awesome, right?

Take me back, please!

AbdlrahmanSaber — Sun, 24 Apr 2022 16:28:46 +0000

Not your best day. You made changes you shouldn’t have and now everything is broken… Is there a way to undo those commits?

Git keeps track of updates to the tip of branches using a mechanism called reference logs, orreflogsMany Git commands accept a parameter for specifying a reference or “ref”, which is a pointer to a commit. Common examples include git checkoutor git reset.

git reflog

you can get the record of all the commits done in Git.

Now you just need to find the commit prior to the one that caused all the hassle. HEAD@{index} represents the specified commit, so just replace the index with the correct number and run:

git reset HEAD@{index}

The default action for git reset is git reset --mixed. It means that the changes in your working directory will be preserved but not staged (since the index was modified to match the chosen commit, the changes are not in the index anymore).

Other options are:

# Doesn’t modify the index or the working tree, leaving your changes staged for commit.
git reset --soft

# Use with caution, as it resets both the index and working tree. Uncommitted changes and all commits after will be removed.

git reset --hard

And now, you can start over from the point when everything in your repository worked like a charm. Remember to use it only locally, as modifying a shared repository is considered a serious crime.

If you found this post useful please share it with your friends 😍

Let’s connect on LinkedIn, Twitter

How view branches sorted by date in specific format and order

AbdlrahmanSaber — Thu, 21 Apr 2022 03:13:20 +0000

This a short tutorial from a git tricks series.

Let's know how we can list all branches sorted by date.

View branch sorted by date

display a list of all local branches and sort them based on the date of their last commit.

# sort desc (-committerdate)
git branch --sort=-committerdate

# sort asc (committerdate)
git branch --sort=-committerdate

If you’d like to make a custom format you can use for-each-ref with --sort option and --format option to write your format.

git for-each-ref --sort='-committerdate' --format='%(refname)%09%(committerdate)' refs/heads

In the above command, I print the refname first then commitdate in --format option the output will be like this

refs/heads/branch_name commitdate
refs/heads/branch_name2 commitdate

# real output
refs/heads/new_design   Wed Apr 20 12:24:21 2022 +0200

refs/heads/design_assets        Wed Apr 20 11:30:30 2022 +0200

If you want to print the date first then refname, the option format will be like this --format='%(committerdate)%09%(refname)%'

Let’s say you don’t want to print refs/heads and want print just the branch name each time, how we can do this? by using sed.

git for-each-ref --sort='-committerdate' --format='%(refname)%09%(committerdate)' refs/heads | sed 's-refs/heads/--'

#output
branch_name commitdate
branch_name2 commitdate

#real output
new_design      Wed Apr 20 12:24:21 2022 +0200

design_assets   Wed Apr 20 11:30:30 2022 +0200

I find these commands incredibly helpful when returning to work from a weekend or just jumping from project to project. Hopefully, you can use these commands too!

If you found this post useful please share it with your friends 😍

Let’s connect on LinkedIn, Twitter

Is it possible to create a commit with a different date?

AbdlrahmanSaber — Wed, 20 Apr 2022 04:02:32 +0000

This a first short tutorial from a Git Tricks series.

Sometimes, you might run into a situation where you need to create a commit with a different date than the current one. Luckily, you can handle this using following timestamp in git

GIT_AUTHOR_DATE
GIT_COMMITTER_DATE

you might be now you're wondering what's actually the difference between Author and Committer

Let's Understanding dates in Git: author date vs. committer date & ‘approxidate

The author is the person who originally wrote the work, whereas the committer is the person who last applied the work.

So if, for instance, you send in a patch to a project, the author date will be when you made the original commit but the committer date will be when the patch was applied. Another common scenario is rebasing: rebasing will alter the commit date, but not the author date.

The Command


GIT_AUTHOR_DATE='Mon May 18 19:32:11 2022 -0400' \
  GIT_COMMITTER_DATE='Mon May 18 19:32:11 2022 -0400'\
  git commit -m 'Commit from the past'

As shown in the example above, you can set both values to any date you like and your code will be committed on that date.

Note
you can also use other formats

Date formats

RFC 2822 Mon, 18 May 2022 19:32:11 -0400
ISO 8601 2022-05-18 19:32:11 -0400
local Mon May 18 19:32:11 2022
short 2022-05-18
relative 5.seconds.ago, 2.years.3.months.ago, 6am yesterday

Let’s connect on LinkedIn, Twitter

How organize big projects in Laravel?

AbdlrahmanSaber — Tue, 19 Apr 2022 08:20:41 +0000

Agenda

Introduction
What’s HMVC?
Advantages of using HMVC?
What’s wrong with the MVC pattern?
Let’s know how we can use the HMVC pattern in Laravel!
Pros
Cons
Best Packages that generate modules and implement that approach
Conclusion

Introduction

Everyone when beginning a new project starts to ask himself/herself the following question?

How can I make organized the project well to be easy for me or for any other developer easy to understand for example if you’re looking for a file in a big project, you want to be easy to find that file, right?

We have many approaches and design patterns that make the project clean but in this article, I will talk about HMVC (the Hierarchical-model-view-controller) pattern which makes your application modular.

What’s HMVC?

The HMVC pattern extends the MVC pattern and is a solution to overcome scalability problems apparent within large MVC applications.

An HMVC application operates using a collection of MVC entities where each MVC entity can execute without the presence of any other. Ideally, each entity should never load models or libraries of other entities.

Advantages of using HMVC?

HMVC supports the reuse of code
HMVC allows easy distribution of MVC entities stored in a single directory.
HMVC reduces dependencies and allows to easily extend applications while retaining ease of maintenance.
Testing is easier because the system is divided to a large extend into independent parts.

What’s wrong with the MVC pattern?

The Model-View-Controller (MVC) paradigm remains one of the more enduring patterns. However, the traditional MVC scope falls short when it comes to the control of GUI elements (widgets). MVC does not handle the complexities of data management, event management, and application flows.

HMVC provides a powerful yet easy-to-understand layered design methodology for developing a complete presentation layer.

Let’s know how we can use the HMVC pattern in Laravel!

Let’s assume we have an accounting project that has (Banking — Sale— Transaction), the question now is how we can organize the project using HMVC! let’s divide these three parts into MVC components so you can have each of them separately developed but used as one!

Example from a real accounting project

Each module has its own (routes - middleware - controllers- etc..), and it’s help you to make your project more organized.

Pros

Modularization: reduction of dependencies between the disparate parts of the application.
More organized: having a folder for each of the relevant triads makes for a lighter workload.
Reusability: by the nature of the design it is easy to reuse nearly every piece of code.
Extendibility: this makes the application more extensible without sacrificing ease of maintenance.

Cons

Create More Folders But the solution of it in my opinion that we will remove unused folders.

Best Packages that generate modules and implement that approach

we have many packages with Laravel that generate modules but I will share in this article my own package (Laragine) and other packages that I used in many projects.

Laravel Modules

Is a Laravel package that was created to manage your large Laravel app using modules.
This package just structures your project (Modules) and doesn’t provide any implementation.

Laragine

is a Laravel package that was created to manage your large Laravel app using modules also but here’s a difference, this package implements all API CRUD operations with unit tests, the package generates (Controller — Model — Factories — Migrations — unit tests — etc..), all you need to do to just add your API route in your route folder and everything (APIs CRUD operations) will work magically sounds interesting, right!
check this video to know more.
I wrote a series of blogs about it you can check it from here https://dev.to/abdlrahmansaberabdo/series/14891
Check the documentation

Conclusion

Basically, the HMVC pattern is just an extension of MVC. An HMVC application includes one or more MVC sub-applications. so anything MVC can do, HMVC can do too. Now, it depends on whether you need the flexibility and scalability that HMVC offers.

Let’s connect on LinkedIn, Twitter

Do we have pointers in python like other programming !

AbdlrahmanSaber — Wed, 16 Feb 2022 09:21:22 +0000

Pointer is important to understand for the way you’re going to create data structures.

I’m going to start with something that is not a pointer and then compare it to something that does use a pointer.

Let’s say that we have two variable num1, num2

num1 = 11, 
num2 = num1

print("Before: ")
print(num1) #11
print(num2) #11

# then let's change num1

num1 = 22

print("\nAfter\n")
print("num1 =", num1) #22
print("num2 =", num2) #11

If you realized num2 is still the same 11, you’re wondering now why num2 still equals the same number, is it should update to 22 because we update num1!

So when you set num1 = num2, these are not linked forever, you are just initializing, and that is what happens when you’re working with something that is not using a pointer.

Now, let’s compare this to something that does use a pointer.

We’re going to use a dictionary in python, when you have something set equal to a dictionary, it’s a pointer to the dictionary.
Let’s use the same example and see.

dict1 = {
    'value': 11
}

dict2 = dict1

print("Before: ")

print("num1= ", dict1) # {value: 11}
print("num2= ", dict2) # {value: 11}

dict1['value'] = 22

print("\nAfter\n")

print("num1= ", dict1) # {value: 22}
print("num2= ", dict2) # {value: 22}

so when you set dict2 = dict1 , you are literally saying dict2 points to the exact same dictionary in memory as dict1.

There are a couple of other concepts I want to show here.

The first concept is, let’s just say we have another dictionary called dict3

dict3 = {'value': 57}

dict2 = dict3

print (dict2) # {value: 57}

The pointer can be redirected like this also, and this idea of having a pointer point to a new place is a concept that you’ll use in a data structure.

The second concept is, let’s say now we set dict1 = dict2 now all variables (dict1 — dict2 — dict3)
are pointing to {'value':57} so you might ask now, what happens to that dictionary {'value': 22} which is the old value for dict1 before pointing to dict3. is not a way to get that pointer again {'value': 22}? yes no way to get this pointer again, now we should ask what python does to free this memory up?

Good question, python will run a process called garbage collection to remove this.

If you like the post leave a comment and tell me if you’d like to make a series of posts about data structure and how we can use pointers in it.

Let’s connect on LinkedIn

Understand how the views work in Laragine (a package in laravel)

AbdlrahmanSaber — Wed, 06 Oct 2021 22:29:36 +0000

In the previous tutorials we created a fully CRUD API with unit tests, in this tutorial we'll understand how to work with views in Laragine.

When we installed Laragine in the previous tutorial, it's created under the core folder as we know, and also it has created a folder called the Base, we can't discuss everything in the Base folder in this tutorial, but I'll explain it separately.

under Base folder there are two folders called views - unit_template.

In the views folder there's a folder called layout, in layout folder you should create the base views for your website like navbar sidebar - buttons - etc..

What's `unit_template` for, in `core\Base`?

let's assume that you'll create a blog, the blog has units like post - comment - like, each unit will have get - store - update - delete methods, right?

So each unit will have a form for creating - update and a page for showing all units - specific unit, so in each unit, you'll create these files and implement it, instead of creating the views each time in the unit you can put the default views that will be in each unit like form - table - show page and when create a unit you'll just add the non-common other stuff like attributes - titles - etc.. in the form - table - show page - etc.. and make minor changes depends on your project and your way.

let's go to the unit_template folder in core\Base you'll see five files _form - create - edit - index - show you can remove the current code it's just an example and put your own code inside it and make a style for it. you might be thinking now how can I use these files!

Note

Please take a look at the blade files inside core/Base/views and core/Base/unit_template you will notice that $global variable is shared across all the views, the $global variable will help you to load views - route dynamically.
I'll make seperated tutorial about the $global variable

I'll edit the _form file as an example in core/Base/unit_template

Let's create a new unit called comment under blog module
Blog module that we created in the previous tutorial
php artisan laragine:unit comment --module=blog --init
now I'll not discuss what we should do with JSON file if you don't know please see previous tutorial number (1)
Let's run the second part of unit command
php artisan laragine:unit comment --module=blog
let's go to core\Blog\views\comment
if you remember I have just updated the _form file in core/Base/unit_template let's see it in the views in comment unit

it's the same code that I put in the _form file in the core/Base/unit_template folder, right? so we can conclude that each unit will copy the code under the core\Base\unit_template folder.

What're the benefits?
You might be wondering now what're the benefits of doing this, you don't need to write the same code each time in default files in each unit like forms - tables - shows page, you will just put your template with all style then the views will be created automatically for you, then you'll just write other stuff like attributes - titles - etc.. inside them.

*I mean by saying attributes the name of attributes in your table let's say when creating a _form view, you'll need to create new inputs for each attribute like title - body - etc..

Now let's put a route for views

go to core\Blog\routes\web.php and add Route::resource('comments', 'CommentController')->except([ 'store', 'update', 'destroy' ]);

Testing

now let's test the view, you can run php artisan serve to create http-server for your project HTTP-server will listen to port 8000
let's go to http://localhost:8000/admin/commentsmain domain - route

The style is not our main goal in this tutorial I just want to teach you how to work with views in Laragine, you can navigate to any route you want for comments.

let's go to http://localhost:8000/admin/comments/create

If you realized my template appears as I edited in the _form file which is just My Form text.

That's all the basic usage of Views in Laragine,
have fun experimenting in Laragine

How to use Unit tests in Laragine

AbdlrahmanSaber — Mon, 04 Oct 2021 19:04:20 +0000

In the previous tutorial, I taught you how to create a fully CRUD API, let's continue the journey and learn how to use Laragine to test the API that we created in the previous tutorial.

Steps:

We need to do 3 things in phpunit.xml in the root directory:

Change the value of the bootstrap attribute to vendor/yepwoo/laragine/src/autoload.php in PHPUnit tag (it's the same as vendor/autoload.php but with needed stuff to run the tests correctly in the generated modules and units).
Add the following to the Unit test suite:

<directory suffix=".php">./core/*/Tests/Feature</directory>
<directory suffix=".php">./plugins/*/Tests/Feature</directory>

add the following to Feature test suite:

<directory suffix=".php">./core/*/Tests/Feature</directory>

<directory suffix=".php">./plugins/*/Tests/Feature</directory>

*Here's the full code snippet: *

Let's go to PostTest.php in core/Blog/Tests/Feature
There're five main functions in the file:
testItShouldGetListingOfTheResource() for testing get the lists of the the resource.
testItShouldStoreNewlyCreatedResource() for testing create a new resource in the storage.
testItShouldGetSpecifiedResource() for testing get a specefied the resource.
testItShouldUpdateSpecifiedResource() for testing update a resource in the storage
testItShouldRemoveSpecifiedResource() for testing remove a resource from the storage

Note

you can edit the unit tests function as you want, we just write the main methods for each CRUD.

Now open your terminal or git bash in your project and let's run the test, you can run one of the following commands:

php artisan test
./vendor/bin/phpunit

Conclusion

I hope you found this article helpful. If you need any help please let me know in the comment section.

Let's connect on LinkedIn

How to create a fully crud API without implementing the CRUD functions in laravel!

AbdlrahmanSaber — Mon, 04 Oct 2021 17:55:37 +0000

Good day, today we are going to build a fully CRUD system (Web & API). API is a software intermediary that allows two applications to talk to each other. Somethings you might need to create an app that can be run on different languages or frameworks, for example, you can use Laravel to create the backend for your application while the frontend might run on any JavaScript frameworks. API allows two or more programs to communicate with each other.
There are different types of APIs, but today we are going to concentrate on RESTful APIs. REST stands for Representational State Transfer, while API stands for Application Programming Interface. You can read more about API from the internet or other programming material.

Click on my profile to follow me to get more updates.

Prerequisites

We'll use a laravel package called Laragine, this package helps us to create a fully CRUD system by just writing simple commands Without saying much, let's dive into it.

What is Laragine?

Laragine is a laravel package which was created to manage your large laravel app using modules, let's say that you'll build a blog the blog consist of (post - comment - like), blog-> is a module, (post - comment - like) -> called units *laragine built the module & units with all CRUD functionalities also built *(Migrations - factories - tests - controllers - models) all you have to do is to just include the link in route files, awesome, right!

In this tutorial, we'll just create a post for a blog with fully CRUD functionalities so we'll create a module called blog then we'll create a unit called post

STEP 1: install laravel 8

To install the latest laravel framework, which is laravel 8.0 as of the time of publishing this article, run the command below
composer create-project --prefer-dist laravel/laravel laravel_8
This will automatically create a laravel 8 app and some couple of things have been set up, we don’t need to copy and rename the env.example file, Laravel 8 does that automatically for us.

Another important thing about Laravel 8, you don’t need to generate APP_KEY, this new version will also generate it for us.

With that all set up, our app is ready.

STEP 2: Database setup

Create an empty database, Open the .env file, and update your database configurations.

STEP 3: Require Laragine package

Let us install Laragine.

composer require yepwoo/laragine

STEP 4: Install the package

After including Laragine, you have to install it by running the following command:
php artisan laragine:install
it's an initial command for Laragine

Note

After running the command, the Laragine directory will be in the root directory under core directory.

If you want to know more information about the package visit the documentation

STEP 5: Create a blog module

Run the following command and specify the name of the module in our case will be blog
php artisan laragin:module blog

Any module will be added under core directory After running the command, the **blog** directory will be in thecore` directory.

STEP 6: Create unit

After creating our module (blog) we need to create a post, right?
The unit command consists of 2 commands
Init command:
Creates all basic files and will create a JSON file that we'll specify the attributes that we want to add it to the database, we should specify the name of the module that we want to add the unit under it, which is blog in this example.

Second command:
it's the same command without init option, the command will automatically create all the following files depending on the data that we specified in the JSON file.

Migration
Requests
Resources
Factories
unit tests

let's run the commands, we should specify name of the module that we want to create the unit under it & the name of unit

php artisan laragin:unit post --module=blog --init

We include --init because it's the first part of unit command
After running the command it'll generate the basic files Controller (API - web) - Model & also the JSON file that we'll write our attributes in it.

Now we should specify our attributes in the Post.json file, let's first know what the attributes that we need! let's start with the basics in this article I just want to show you how to use the package, you can add any amount of attributes you want, any post have title, body, thumbnail

Note

if we don't put the attribute as nullable will be required by default

Attributes:

title -> type: string, definition: unique
body -> type: text,
image -> type: string, definition: nullable

Now let's go to the JSON file which is in core/blog/data/Post.json to write our attributes.

Note

we should follow rules when writing any attribute in JSON file, there are two types of configuration type & definition

type: is the type of attribute you should write it as Laravel specified in docs you can check all types in Laravel from here
definition: is for column modifier also you should write it as `Laravel specified in the docs you can check it from here

if you realized that I didn't write required because the package will add it automatically.

Let's run the second part of `unit command`

php artisan laragin:unit post --module=blog

After running the command it'll generate migrations - requests - resources - factories - unit tests - etc... files and they are fully implemented.

let's see the migration file, you'll see all attributes are added automatically with the configuration that we specified in JSON file, magic, right🧐!

Now let's run migrate command php artisan migrate

STEP 7: Add API route

add Route::apiResource('posts', 'PostController'); in api.php in core\Blog\routes\api.php

Note

we don't need to implement CRUD methods, it's aleardy implemented in PostController in core\Blog\Controllers\API\PostController.

STEP 8: Testing

open Postman or any other software you use to test the API
let's first create a new post
let's create another post but without including the title to just test if it'll return error or not
Now you're wondering how it gives us that the title attribute is required, right 🤔? let's see PostRequest file in core/Blog/Requests, all attributes that we specefied is in the file with some validation, Laragine does this job for us.

note

you can modify any attribute you want in request file or in any other file Resources - unit test - etc...

Let's get all posts
Let's update the post
before testing update method, you may want to change the validation in the update request (put) and you can do this from PostRequest in core/Blog/Requests file in put method

Let's delete the post

Conclusion

in this article I just showed you one feature of Laragine package, in the next tutorial I'll teach you how to use
unit tests by just making a small configuration.

Let's connect on LinkedIn

Forem: AbdlrahmanSaber

Stop Starting From Scratch: How Claude Projects Will Change the Way You Work

What Is a Claude Project?

Custom Instructions: The Feature Most People Skip

Knowledge Files: Give Claude Something to Work With

Five Projects Worth Creating Today

Tips for Getting the Most Out of Projects

The Bigger Shift

Debug MCP Like Network Tab: Seeing Every Tool Call in Real Time

Disclosure

What is MCP?

The black box

Transparent proxy: no server surgery

What you see on the dashboard

CLI options worth knowing

What's next

For multi-server setups you want one shared dashboard and a Server column — that’ll be in the next article. mcpkit serve plus mckit proxy with --inspector in each configured command (adapt the snippet to your tool’s JSON shape).

Links

Feel free to connect 🌹me on:

Convert enum to string literal union type in TS

Take me back, please!

How view branches sorted by date in specific format and order

View branch sorted by date

Is it possible to create a commit with a different date?

Let's Understanding dates in Git: author date vs. committer date & ‘approxidate

The Command

Date formats

How organize big projects in Laravel?

Agenda

Introduction

What’s HMVC?

Advantages of using HMVC?

What’s wrong with the MVC pattern?

Let’s know how we can use the HMVC pattern in Laravel!

Pros

Cons

Best Packages that generate modules and implement that approach

Laravel Modules

Laragine

Conclusion

Do we have pointers in python like other programming !

Understand how the views work in Laragine (a package in laravel)

What's unit_template for, in core\Base?

Note

Now let's put a route for views

Testing

How to use Unit tests in Laragine

Steps:

Note

Conclusion

How to create a fully crud API without implementing the CRUD functions in laravel!

Prerequisites

What is Laragine?

STEP 1: install laravel 8

STEP 2: Database setup

STEP 3: Require Laragine package

STEP 4: Install the package

Note

STEP 5: Create a blog module

STEP 6: Create unit

Note

Attributes:

Note

Let's run the second part of unit command

STEP 7: Add API route

Note

STEP 8: Testing

note

Conclusion

For multi-server setups you want one shared dashboard and a Server column — that’ll be in the next article. `mcpkit serve` plus `mckit proxy` with `--inspector` in each configured command (adapt the snippet to your tool’s JSON shape).

What's `unit_template` for, in `core\Base`?

Let's run the second part of `unit command`