While creating a mod for Starbound you might run into a situation, where you need to edit .json and .config files, that are originally present in Starbound's assets (or assets of another mod).
In this case in most situations it's best to not edit them directly, and instead create a .patch file that adds/edits/removes data from these files.

This is called JSON-Patching. You can read more about it here[jsonpatch.com].

First, you need to create a .patch file.
The name of this file should be a copy of the name of a file you want to patch.
Example: if you want to patch a file called stone.json, you need to name your patching file stone.json.patch.

Now, you need to write its contents. There are 2 ways to do this:

1. Writing it yourself
   
   The syntax for .patch files can be found on this website[jsonpatch.com].
   Keep in mind that Starbound has an extended syntax it supports, for that checkout the "Useful Materials" section.
   
   Note: please do not forget, that every patch file should contain a list of objects (patches themselves), even if there's only one patch.
   
   Example:
   
   [ { "op" : "add", "path" : "/items/-", "value" : "myvalue1" }, { "op" : "add", "path" : "/items/-", "value" : "myvalue2" } ]
   
   
2. Using online services
   
   There is this helpful service[json-patch-builder-online.github.io] that lets you provide the initial contents of a file you need to patch, and the expected results.

To check, that your .patch file works correctly, you can use this service[json-schema-validator.herokuapp.com] or this one[jsonpatch.me].
Keep in mind that Starbound might still process your patches slightly differently than here.

We're almost done.

There's a couple of rules on how the game applies these patches:

• Your patch file should be located on the same relative path as the file you are patching.
  Example:
  Let's say your mod is called my_cool_mod and you are trying to patch a file called distributions.config, located in Starbound assets at packed/biomes/distributions.config.
  In this case you need to put your patch file on this path: .../my_cool_mod/biomes/distributions.config.patch
  
• It is possible to use .patch files to edit files from other mods. To do that, all you need to know is the relative path of the file you want to patch.
  Example:
  Let's say your mod is called my_cool_mod and you are trying to patch a file called superfile.json from mod other_mod at .../other_mod/items/superfile.json.
  In this case you need to put your patch file on this path: .../my_cool_mod/items/superfile.json.patch

That's it! You're good to go!

While usually one ".patch" file contains a list of patches to be performed, you could optionally batch those patches to divide them into separate groups - this way instead of containing a plain list of patches, your file will contain a list of lists of patches, or a list of patch batches, like so:
Why do this? Discover in the next section!

What if you needed to apply a patch to a file, only if it contained a specific field?
For example, if you're not sure, if the file can be overwritten by a different mode that removes that value.

In that case, you could use a "test" patch operation, that checks if the existing parameter exists, or if it contains a specific value.

Specifying value will check if the key is equal to that specific value, omitting it will simply check for existence of that key under the specified path.
Adding ""inverse" : true" will invert the test, like adding "not" to a programming condition.

Taken from a post made by a game dev, link in the end of the guide:

Note: if a test fails, all of the patches in the current batch (or file, if you're not using batches) won't apply.

What if you need to apply different patches to a file under different conditions? If a key is equal to true, then add this, if it's false, then remove this.
Or, what if you have patches, that should be applied no matter what, and also have patches that should only be applied under a specific condition?

This is where you want to use batches.
A failing test will only discard all patches in a batch, so the other batches will be independant from it.

These are some useful links that cover a lot of use cases and might answer some of your questions.

A very extensive, but quite old guide that also covers this topic:
Basic Patching Now With Path Guide [v1.9][community.playstarbound.com] - by The | Suit

Extended functionality for the "test" operation supported by Starbound:
You can invert tests and you can check just for existence of a key[community.playstarbound.com]

Starbound supports Patch Batches - when a patch file contains multiple lists of patches. Useful with "test" operations for conditional patching:
Patch Batches[community.playstarbound.com]

I've made this guide mainly for referencing it in other guides.
This guide assumes you know how to unpack game files.
Please let me know if I forgot or mixed up anything.
Thank you for reading!